PlayerDumpReader Class Reference

#include "PlayerDump.h"

Inheritance diagram for PlayerDumpReader:

Public Member Functions
	PlayerDumpReader ()
DumpReturn	LoadDumpFromFile (std::string const &file, uint32 account, std::string name, ObjectGuid::LowType guid)
DumpReturn	LoadDumpFromString (std::string const &dump, uint32 account, std::string name, ObjectGuid::LowType guid)

Private Member Functions
DumpReturn	LoadDump (std::istream &input, uint32 account, std::string name, ObjectGuid::LowType guid)

Additional Inherited Members
Static Public Member Functions inherited from PlayerDump
static void	InitializeTables ()
Protected Member Functions inherited from PlayerDump
	PlayerDump ()

Detailed Description

Constructor & Destructor Documentation

PlayerDumpReader()

PlayerDumpReader::PlayerDumpReader ( )

inline

{ }

Member Function Documentation

LoadDump()

DumpReturn PlayerDumpReader::LoadDump ( std::istream &  input, uint32  account, std::string  name, ObjectGuid::LowType  guid  )

private

{
    uint32 charcount = AccountMgr::GetCharactersCount(account);
    if (charcount >= 10)
        return DUMP_TOO_MANY_CHARS;
 
    std::string newguid, chraccount;
 
    // make sure the same guid doesn't already exist and is safe to use
    bool incHighest = true;
    if (guid && guid < sObjectMgr->GetGenerator<HighGuid::Player>().GetNextAfterMaxUsed())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHECK_GUID);
        stmt->SetData(0, guid);
 
        if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
            guid = sObjectMgr->GetGenerator<HighGuid::Player>().GetNextAfterMaxUsed();                     // use first free if exists
        else
            incHighest = false;
    }
    else
        guid = sObjectMgr->GetGenerator<HighGuid::Player>().GetNextAfterMaxUsed();
 
    // normalize the name if specified and check if it exists
    if (!normalizePlayerName(name))
        name.clear();
 
    if (ObjectMgr::CheckPlayerName(name, true) == CHAR_NAME_SUCCESS)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHECK_NAME);
        stmt->SetData(0, name);
 
        if (PreparedQueryResult result = CharacterDatabase.Query(stmt))
            name.clear();                                       // use the one from the dump
    }
    else
        name.clear();
 
    // name encoded or empty
    newguid = std::to_string(guid);
    chraccount = std::to_string(account);
 
    std::map<ObjectGuid::LowType, ObjectGuid::LowType> items;
    ObjectGuid::LowType itemLowGuidOffset = sObjectMgr->GetGenerator<HighGuid::Item>().GetNextAfterMaxUsed();
 
    std::map<ObjectGuid::LowType, ObjectGuid::LowType> mails;
    ObjectGuid::LowType mailLowGuidOffset = sObjectMgr->_mailId;
 
    std::map<ObjectGuid::LowType, ObjectGuid::LowType> petIds;
    ObjectGuid::LowType petLowGuidOffset = sObjectMgr->_hiPetNumber;
 
    std::map<uint64, uint64> equipmentSetIds;
    uint64 equipmentSetGuidOffset = sObjectMgr->_equipmentSetGuid;
 
    std::string line;
 
    uint8 gender = GENDER_NONE;
    uint8 race = RACE_NONE;
    uint8 playerClass = CLASS_NONE;
    uint8 level = 1;
 
    // for logs
    std::size_t lineNumber = 0;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    while (std::getline(input, line))
    {
        ++lineNumber;
 
        // skip empty strings
        std::size_t nw_pos = line.find_first_not_of(" \t\n\r\7");
        if (nw_pos == std::string::npos)
            continue;
 
        // skip the important notes
        static std::string const SkippedLine = "IMPORTANT NOTE:";
        if (line.substr(nw_pos, SkippedLine.size()) == SkippedLine)
            continue;
 
        // determine table name and load type
        std::string tn = GetTableName(line);
        if (tn.empty())
        {
            LOG_ERROR("misc", "LoadPlayerDump: (line {}) Can't extract table name!", lineNumber);
            return DUMP_FILE_BROKEN;
        }
 
        DumpTableType type = DTT_CHARACTER;
        uint32 i;
        for (i = 0; i < DUMP_TABLE_COUNT; ++i)
        {
            if (tn == DumpTables[i].Name)
            {
                type = DumpTables[i].Type;
                break;
            }
        }
 
        if (i == DUMP_TABLE_COUNT)
        {
            LOG_ERROR("misc", "LoadPlayerDump: (line {}) Unknown table: `{}`!", lineNumber, tn);
            return DUMP_FILE_BROKEN;
        }
 
        TableStruct const& ts = CharacterTables[i];
        if (!ValidateFields(ts, line, lineNumber))
            return DUMP_FILE_BROKEN;
 
        // per field guid offsetting
        for (TableField const& field : ts.TableFields)
        {
            if (!field.IsDependentField)
                continue;
 
            switch (field.FieldGuidType)
            {
            case GUID_TYPE_ACCOUNT:
                if (!ChangeColumn(ts, line, field.FieldName, chraccount))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_CHAR:
                if (!ChangeColumn(ts, line, field.FieldName, newguid))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_PET:
                if (!ChangeGuid(ts, line, field.FieldName, petIds, petLowGuidOffset))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_MAIL:
                if (!ChangeGuid(ts, line, field.FieldName, mails, mailLowGuidOffset))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_ITEM:
                if (!ChangeGuid(ts, line, field.FieldName, items, itemLowGuidOffset, true))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_EQUIPMENT_SET:
                if (!ChangeGuid(ts, line, field.FieldName, equipmentSetIds, equipmentSetGuidOffset))
                    return DUMP_FILE_BROKEN;
                break;
            case GUID_TYPE_NULL:
            {
                static std::string const NullString("NULL");
                if (!ChangeColumn(ts, line, field.FieldName, NullString))
                    return DUMP_FILE_BROKEN;
                break;
            }
            }
        }
 
        // extra modifications for other tables
        switch (type)
        {
        case DTT_CHARACTER:
        {
            race = *Acore::StringTo<uint32>(GetColumn(ts, line, "race"));
            playerClass = *Acore::StringTo<uint32>(GetColumn(ts, line, "class"));
            gender = *Acore::StringTo<uint32>(GetColumn(ts, line, "gender"));
            level = *Acore::StringTo<uint32>(GetColumn(ts, line, "level"));
            if (name.empty())
            {
                // generate a temporary name
                std::string guidPart = Acore::StringFormat("{:X}", guid);
                std::size_t maxCharsFromOriginalName = MAX_PLAYER_NAME - guidPart.length();
 
                name = GetColumn(ts, line, "name").substr(0, maxCharsFromOriginalName) + guidPart;
 
                // characters.at_login set to "rename on login"
                if (!ChangeColumn(ts, line, "name", name))
                    return DUMP_FILE_BROKEN;
                if (!ChangeColumn(ts, line, "at_login", "1"))
                    return DUMP_FILE_BROKEN;
            }
            else if (!ChangeColumn(ts, line, "name", name)) // characters.name
                return DUMP_FILE_BROKEN;
            break;
        }
        default:
            break;
        }
 
        FixNULLfields(line);
 
        trans->Append(line.c_str());
    }
 
    if (input.fail() && !input.eof())
        return DUMP_FILE_BROKEN;
 
    CharacterDatabase.CommitTransaction(trans);
 
    // in case of name conflict player has to rename at login anyway
    sCharacterCache->AddCharacterCacheEntry(ObjectGuid(HighGuid::Player, guid), account, name, gender, race, playerClass, level);
 
    sObjectMgr->GetGenerator<HighGuid::Item>().Set(sObjectMgr->GetGenerator<HighGuid::Item>().GetNextAfterMaxUsed() + items.size());
    sObjectMgr->_mailId += mails.size();
    sObjectMgr->_hiPetNumber += petIds.size();
    sObjectMgr->_equipmentSetGuid += equipmentSetIds.size();
 
    if (incHighest)
        sObjectMgr->GetGenerator<HighGuid::Player>().Generate();
 
    sWorld->UpdateRealmCharCount(account);
 
    return DUMP_SUCCESS;
}

References ChangeColumn(), ChangeGuid(), CHAR_NAME_SUCCESS, CHAR_SEL_CHECK_GUID, CHAR_SEL_CHECK_NAME, CharacterDatabase, CharacterTables, ObjectMgr::CheckPlayerName(), CLASS_NONE, DTT_CHARACTER, DUMP_FILE_BROKEN, DUMP_SUCCESS, DUMP_TABLE_COUNT, DUMP_TOO_MANY_CHARS, DumpTables, TableField::FieldGuidType, TableField::FieldName, FixNULLfields(), GENDER_NONE, AccountMgr::GetCharactersCount(), GetColumn(), GetTableName(), GUID_TYPE_ACCOUNT, GUID_TYPE_CHAR, GUID_TYPE_EQUIPMENT_SET, GUID_TYPE_ITEM, GUID_TYPE_MAIL, GUID_TYPE_NULL, GUID_TYPE_PET, TableField::IsDependentField, LOG_ERROR, MAX_PLAYER_NAME, normalizePlayerName(), RACE_NONE, sCharacterCache, PreparedStatementBase::SetData(), sObjectMgr, Acore::StringFormat(), sWorld, TableStruct::TableFields, DumpTable::Type, and ValidateFields().

Referenced by LoadDumpFromFile(), and LoadDumpFromString().

LoadDumpFromFile()

DumpReturn PlayerDumpReader::LoadDumpFromFile	(	std::string const &	file,
		uint32	account,
		std::string	name,
		ObjectGuid::LowType	guid
	)

{
    std::ifstream input(file);
    if (!input)
        return DUMP_FILE_OPEN_ERROR;
    return LoadDump(input, account, name, guid);
}

References DUMP_FILE_OPEN_ERROR, and LoadDump().

LoadDumpFromString()

DumpReturn PlayerDumpReader::LoadDumpFromString	(	std::string const &	dump,
		uint32	account,
		std::string	name,
		ObjectGuid::LowType	guid
	)

{
    std::istringstream input(dump);
    return LoadDump(input, account, name, guid);
}

References LoadDump().