feat(glue): add realm and character handling (#7)

* fix(build): make project compilable

* feat(glue): update Character Selection screen to support switching

* fix(ui): fix CSimpleFontString::GetHeight() to use proper method

* feat(db): add static database classes from whoa-autocode

* feat(ui): use class and area IDs for Character Selection

* chore(db): update ItemRandomPropertiesRec

* feat(glue): update CCharacterSelection methods

* chore(db): uncomment DB records

* feat(glue): implement character deletion

* feat(gx): update supported text tags in GxuDetermineQuotedCode

* fix(ui): fix CSimpleFontString to use the FixedColor flag only if the string does not contain color tags

* feat(net): implement GrunLogin::LogOff

* feat(net): implement NetClient::Disconnect

* feat(login): implement trimming of realm name in LoginResponse::HandleRealmData

* feat(net): implement proper disconnection from login and realm servers

* feat(net): implement PING/PONG messages

* feat(net): add NetClient::Destroy method

* feat(net): implement ClientServices::GetRealmList (second request of Realm List)

* feat(glue): implement CGlueMgr::PollRealmList

* feat(glue): implement CGlueMgr::PollCreateCharacter

* chore(glue): add skeleton of CCharacterComponent class

* fix(build): fix build using latest features

* fix(glue): kill gotos in CGlueMgr::NetDisconnectHandler

* fix(build): include SDL3

---------

Co-authored-by: superp00t <superp00t@tutanota.com>

src/client/Client.cpp

@@ -39,6 +39,7 @@ CVar* Client::g_accountUsesTokenVar;
 CVar* Client::g_movieVar;
 CVar* Client::g_expansionMovieVar;
 CVar* Client::g_movieSubtitleVar;
+CVar* Client::g_lastCharacterIndex;
 
 
 HEVENTCONTEXT Client::g_clientEventContext;
@@ -168,6 +169,16 @@ void ClientRegisterConsoleCommands() {
         false
     );
 
+    Client::g_lastCharacterIndex = CVar::Register(
+        "lastCharacterIndex",
+        "Last character selected",
+        0,
+        "0",
+        nullptr,
+        GAME,
+        false,
+        nullptr,
+        false);
     // TODO
 }
 
@@ -633,6 +644,12 @@ void DestroyGlobal() {
     // TODO
 }
 
+void StormDestroy() {
+    // TODO
+
+    SRegDestroy();
+}
+
 void CommonMain() {
     StormInitialize();
 
@@ -670,8 +687,9 @@ void CommonMain() {
         DestroyGlobal();
     }
 
+    StormDestroy();
+
     // TODO:
-    // StormDestroy();
     // Misc Cleanup
 }
 

src/client/Client.hpp

@@ -14,6 +14,7 @@ namespace Client {
     extern CVar* g_movieVar;
     extern CVar* g_expansionMovieVar;
     extern CVar* g_movieSubtitleVar;
+    extern CVar* g_lastCharacterIndex;
     extern HEVENTCONTEXT g_clientEventContext;
     extern char g_currentLocaleName[5];
 }

src/client/ClientServices.cpp

@@ -9,6 +9,113 @@
 #include <bc/Memory.hpp>
 #include <storm/String.hpp>
 
+static const char* s_errorCodeTokens[] = {
+    "RESPONSE_SUCCESS",
+    "RESPONSE_FAILURE",
+    "RESPONSE_CANCELLED",
+    "RESPONSE_DISCONNECTED",
+    "RESPONSE_FAILED_TO_CONNECT",
+    "RESPONSE_CONNECTED",
+    "RESPONSE_VERSION_MISMATCH",
+    "CSTATUS_CONNECTING",
+    "CSTATUS_NEGOTIATING_SECURITY",
+    "CSTATUS_NEGOTIATION_COMPLETE",
+    "CSTATUS_NEGOTIATION_FAILED",
+    "CSTATUS_AUTHENTICATING",
+    "AUTH_OK",
+    "AUTH_FAILED",
+    "AUTH_REJECT",
+    "AUTH_BAD_SERVER_PROOF",
+    "AUTH_UNAVAILABLE",
+    "AUTH_SYSTEM_ERROR",
+    "AUTH_BILLING_ERROR",
+    "AUTH_BILLING_EXPIRED",
+    "AUTH_VERSION_MISMATCH",
+    "AUTH_UNKNOWN_ACCOUNT",
+    "AUTH_INCORRECT_PASSWORD",
+    "AUTH_SESSION_EXPIRED",
+    "AUTH_SERVER_SHUTTING_DOWN",
+    "AUTH_ALREADY_LOGGING_IN",
+    "AUTH_LOGIN_SERVER_NOT_FOUND",
+    "AUTH_WAIT_QUEUE",
+    "AUTH_BANNED",
+    "AUTH_ALREADY_ONLINE",
+    "AUTH_NO_TIME",
+    "AUTH_DB_BUSY",
+    "AUTH_SUSPENDED",
+    "AUTH_PARENTAL_CONTROL",
+    "AUTH_LOCKED_ENFORCED",
+    "REALM_LIST_IN_PROGRESS",
+    "REALM_LIST_SUCCESS",
+    "REALM_LIST_FAILED",
+    "REALM_LIST_INVALID",
+    "REALM_LIST_REALM_NOT_FOUND",
+    "ACCOUNT_CREATE_IN_PROGRESS",
+    "ACCOUNT_CREATE_SUCCESS",
+    "ACCOUNT_CREATE_FAILED",
+    "CHAR_LIST_RETRIEVING",
+    "CHAR_LIST_RETRIEVED",
+    "CHAR_LIST_FAILED",
+    "CHAR_CREATE_IN_PROGRESS",
+    "CHAR_CREATE_SUCCESS",
+    "CHAR_CREATE_ERROR",
+    "CHAR_CREATE_FAILED",
+    "CHAR_CREATE_NAME_IN_USE",
+    "CHAR_CREATE_DISABLED",
+    "CHAR_CREATE_PVP_TEAMS_VIOLATION",
+    "CHAR_CREATE_SERVER_LIMIT",
+    "CHAR_CREATE_ACCOUNT_LIMIT",
+    "CHAR_CREATE_SERVER_QUEUE",
+    "CHAR_CREATE_ONLY_EXISTING",
+    "CHAR_CREATE_EXPANSION",
+    "CHAR_CREATE_EXPANSION_CLASS",
+    "CHAR_CREATE_LEVEL_REQUIREMENT",
+    "CHAR_CREATE_UNIQUE_CLASS_LIMIT",
+    "CHAR_CREATE_CHARACTER_IN_GUILD",
+    "CHAR_CREATE_RESTRICTED_RACECLASS",
+    "CHAR_CREATE_CHARACTER_CHOOSE_RACE",
+    "CHAR_CREATE_CHARACTER_ARENA_LEADER",
+    "CHAR_CREATE_CHARACTER_DELETE_MAIL",
+    "CHAR_CREATE_CHARACTER_SWAP_FACTION",
+    "CHAR_CREATE_CHARACTER_RACE_ONLY",
+    "CHAR_CREATE_CHARACTER_GOLD_LIMIT",
+    "CHAR_CREATE_FORCE_LOGIN",
+    "CHAR_DELETE_IN_PROGRESS",
+    "CHAR_DELETE_SUCCESS",
+    "CHAR_DELETE_FAILED",
+    "CHAR_DELETE_FAILED_LOCKED_FOR_TRANSFER",
+    "CHAR_DELETE_FAILED_GUILD_LEADER",
+    "CHAR_DELETE_FAILED_ARENA_CAPTAIN",
+    "CHAR_LOGIN_IN_PROGRESS",
+    "CHAR_LOGIN_SUCCESS",
+    "CHAR_LOGIN_NO_WORLD",
+    "CHAR_LOGIN_DUPLICATE_CHARACTER",
+    "CHAR_LOGIN_NO_INSTANCES",
+    "CHAR_LOGIN_FAILED",
+    "CHAR_LOGIN_DISABLED",
+    "CHAR_LOGIN_NO_CHARACTER",
+    "CHAR_LOGIN_LOCKED_FOR_TRANSFER",
+    "CHAR_LOGIN_LOCKED_BY_BILLING",
+    "CHAR_LOGIN_LOCKED_BY_MOBILE_AH",
+    "CHAR_NAME_SUCCESS",
+    "CHAR_NAME_FAILURE",
+    "CHAR_NAME_NO_NAME",
+    "CHAR_NAME_TOO_SHORT",
+    "CHAR_NAME_TOO_LONG",
+    "CHAR_NAME_INVALID_CHARACTER",
+    "CHAR_NAME_MIXED_LANGUAGES",
+    "CHAR_NAME_PROFANE",
+    "CHAR_NAME_RESERVED",
+    "CHAR_NAME_INVALID_APOSTROPHE",
+    "CHAR_NAME_MULTIPLE_APOSTROPHES",
+    "CHAR_NAME_THREE_CONSECUTIVE",
+    "CHAR_NAME_INVALID_SPACE",
+    "CHAR_NAME_CONSECUTIVE_SPACES",
+    "CHAR_NAME_RUSSIAN_CONSECUTIVE_SILENT_CHARACTERS",
+    "CHAR_NAME_RUSSIAN_SILENT_CHARACTER_AT_BEGINNING_OR_END",
+    "CHAR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME",
+};
+
 ClientConnection* g_clientConnection;
 
 char ClientServices::s_accountName[1280];
@@ -27,6 +134,20 @@ CVar* ClientServices::s_darkPortalVar = nullptr;
 CVar* ClientServices::s_ServerAlertVar = nullptr;
 CVar* ClientServices::s_realmListVar = nullptr;
 
+const char* ClientServices::GetErrorToken(uint32_t token) {
+    if (token < sizeof(s_errorCodeTokens) / sizeof(s_errorCodeTokens[0])) {
+        return s_errorCodeTokens[token];
+    } else {
+        return "";
+    }
+}
+
+bool ClientServices::ValidDisconnect(const void* client) {
+    STORM_ASSERT(client);
+    STORM_ASSERT(ClientServices::s_currentConnection);
+    return client == ClientServices::s_currentConnection;
+}
+
 void ClientServices::ConnectToSelectedServer() {
     if (!ClientServices::s_selectRealmInfoValid && !ClientServices::SetSelectedRealmInfo(0)) {
         ClientServices::Connection()->Complete(0, 39);
@@ -69,13 +190,25 @@ void ClientServices::SetMessageHandler(NETMESSAGE msgId, MESSAGE_HANDLER handler
 }
 
 void ClientServices::GetRealmList() {
-    // TODO
+    STORM_ASSERT(ClientServices::s_currentConnection);
+    ClientServices::s_currentConnection->Initiate(COP_GET_REALMS, 35, nullptr);
+    if (ClientServices::s_loginObj->IsLoggedOn()) {
+        ClientServices::s_loginObj->GetRealmList();
+    } else {
+        ClientServices::s_loginObj->Reconnect();
+    }
 }
 
 void ClientServices::GetCharacterList() {
+    STORM_ASSERT(ClientServices::s_currentConnection);
     ClientServices::s_currentConnection->GetCharacterList();
 }
 
+void ClientServices::EnumerateCharacters(ENUMERATE_CHARACTERS_CALLBACK fcn, void* param) {
+    STORM_ASSERT(ClientServices::s_currentConnection);
+    ClientServices::s_currentConnection->EnumerateCharacters(fcn, param);
+}
+
 void ClientServices::CharacterLogin(uint64_t id, const C3Vector& position) {
     ClientServices::s_currentConnection->CharacterLogin(id);
 }
@@ -110,6 +243,11 @@ const REALM_INFO* ClientServices::GetSelectedRealm() {
     return &ClientServices::s_selectRealmInfo;
 }
 
+void ClientServices::CharacterDelete(uint64_t guid) {
+    STORM_ASSERT(ClientServices::s_currentConnection);
+    ClientServices::s_currentConnection->DeleteCharacter(guid);
+}
+
 void ClientServices::Initialize() {
     if (!g_clientConnection) {
         ClientServices::s_clientRealmResponse = NEW(ClientRealmResponseAdapter);
@@ -235,6 +373,7 @@ void ClientServices::LoginServerStatus(LOGIN_STATE state, LOGIN_RESULT result, c
 
 void ClientServices::RealmEnumCallback(uint32_t a2) {
     auto connection = ClientServices::Connection();
+    STORM_ASSERT(connection);
 
     if (a2 == 1) {
         connection->Complete(0, 23);
@@ -246,7 +385,13 @@ void ClientServices::RealmEnumCallback(uint32_t a2) {
         return;
     }
 
-    // TODO statusCop checks
+    // TODO: Proper implementation 
+    if (connection->m_statusCop != COP_CONNECT) {
+        if (connection->m_statusCop == COP_GET_REALMS) {
+            connection->Complete(1, 36);
+        }
+        return;
+    }
 
     if (ClientServices::LoginConnection()->GetLoginServerType() == 1) {
         // TODO Battlenet logic

src/client/ClientServices.hpp

@@ -32,16 +32,20 @@ class ClientServices : public LoginResponse {
         static CVar* s_patchListVar;
 
         // Static functions
+        static const char* GetErrorToken(uint32_t token);
+        static bool ValidDisconnect(const void* client);
         static void ConnectToSelectedServer();
         static ClientConnection* Connection();
         static ClientServices* GetInstance();
         static void SetMessageHandler(NETMESSAGE msgId, MESSAGE_HANDLER handler, void* param);
         static void GetRealmList();
         static void GetCharacterList();
+        static void EnumerateCharacters(ENUMERATE_CHARACTERS_CALLBACK fcn, void* param);
         static void CharacterLogin(uint64_t id, const C3Vector& position);
         static REALM_INFO* GetRealmInfoByIndex(int32_t index);
         static const char* GetSelectedRealmName();
         static const REALM_INFO* GetSelectedRealm();
+        static void CharacterDelete(uint64_t guid);
         static void Initialize();
         static Login* LoginConnection();
         static void Logon(const char* accountName, const char* password);

src/clientobject/Player_C.cpp

@@ -0,0 +1,51 @@
+#include "clientobject/Player_C.hpp"
+#include "clientobject/Types.hpp"
+#include "db/Db.hpp"
+#include <storm/Error.hpp>
+
+
+const CreatureModelDataRec* Player_C_GetModelName(uint32_t race, uint32_t sex) {
+    STORM_ASSERT(sex < UNITSEX_LAST);
+
+    auto displayId = Player_C_GetDisplayId(race, sex);
+    auto record = g_creatureDisplayInfoDB.GetRecord(displayId);
+    if (!record) {
+        SErrPrepareAppFatal(__FILE__, __LINE__);
+        SErrDisplayAppFatal("Error, unknown displayInfo %d specified for player race %d sex %d!", displayId, race, sex);
+    }
+
+    auto modelData = g_creatureModelDataDB.GetRecord(record->m_modelID);
+    if (!modelData) {
+        SErrPrepareAppFatal(__FILE__, __LINE__);
+        SErrDisplayAppFatal("Error, unknown model record %d specified for player race %d sex %d!", record->m_modelID, race, sex);
+    }
+
+    return modelData;
+}
+
+uint32_t Player_C_GetDisplayId(uint32_t race, uint32_t sex) {
+    STORM_ASSERT(sex < UNITSEX_LAST);
+
+    auto record = g_chrRacesDB.GetRecord(race);
+    if (!record) {
+        SErrPrepareAppFatal(__FILE__, __LINE__);
+        SErrDisplayAppFatal("Error, race %d not found in race table!", race);
+    }
+
+    if (sex == UNITSEX_MALE) {
+        return record->m_maleDisplayID;
+    }
+
+    if (sex == UNITSEX_FEMALE) {
+        return record->m_femaleDisplayID;
+    }
+
+    if (sex == UNITSEX_NONE) {
+        SErrPrepareAppFatal(__FILE__, __LINE__);
+        SErrDisplayAppFatal("Error, attempted to look up model for player with sex %d (UNITSEX_NONE), all players have sex! =D", 2);
+    }
+
+    SErrPrepareAppFatal(__FILE__, __LINE__);
+    SErrDisplayAppFatal("Error, unrecognized sex code %d!", sex);
+    return 0;
+}

src/clientobject/Player_C.hpp

@@ -0,0 +1,14 @@
+#ifndef CLIENTOBJECT_PLAYER_C_HPP
+#define CLIENTOBJECT_PLAYER_C_HPP
+
+#include <cstdint>
+
+
+class CreatureModelDataRec;
+
+
+const CreatureModelDataRec* Player_C_GetModelName(uint32_t race, uint32_t sex);
+uint32_t Player_C_GetDisplayId(uint32_t race, uint32_t sex);
+
+
+#endif // CLIENTOBJECT_PLAYER_C_HPP

src/clientobject/Types.hpp

@@ -0,0 +1,14 @@
+#ifndef CLIENTOBJECT_TYPES_HPP
+#define CLIENTOBJECT_TYPES_HPP
+
+
+enum UNIT_SEX {
+    UNITSEX_MALE = 0x0,
+    UNITSEX_FEMALE = 0x1,
+    UNITSEX_NONE = 0x2,
+    UNITSEX_LAST = 0x3,
+    UNITSEX_BOTH = 0x3,
+};
+
+
+#endif

src/clientobject/Unit_C.cpp

@@ -1,8 +1,49 @@
 #include "clientobject/Unit_C.hpp"
 
-const char* CGUnit_C::GetDisplayRaceNameFromRecord(ChrRacesRec* record, uint8_t sexIn, uint8_t* sexOut) {
-    const char* result;
+#include "db/Db.hpp"
 
+
+const char* CGUnit_C::GetDisplayRaceNameFromRecord(ChrRacesRec* record, uint8_t sexIn, uint8_t* sexOut) {
+    if (sexOut) {
+        *sexOut = sexIn;
+    }
+    if (!record) {
+        return nullptr;
+    }
+    if (!sexIn) {
+        if (record->m_nameMale[0]) {
+            return record->m_nameMale;
+        }
+
+        if (record->m_nameFemale[0]) {
+            if (sexOut) {
+                *sexOut = 1;
+            }
+            return record->m_nameFemale;
+        }
+
+        return record->m_name;
+    }
+
+    if (sexIn != 1) {
+        return record->m_name;
+    }
+
+    if (record->m_nameFemale[0]) {
+        return record->m_nameFemale;
+    }
+
+    if (!record->m_nameMale[0]) {
+        return record->m_name;
+    }
+
+    if (sexOut) {
+        *sexOut = 0;
+    }
+    return record->m_nameMale;
+}
+
+const char* CGUnit_C::GetDisplayClassNameFromRecord(ChrClassesRec* record, uint8_t sexIn, uint8_t* sexOut) {
     if (sexOut) {
         *sexOut = sexIn;
     }

src/clientobject/Unit_C.hpp

@@ -1,11 +1,15 @@
 #ifndef CLIENTOBJECT_UNIT_C_HPP
 #define CLIENTOBJECT_UNIT_C_HPP
 
-#include "db/rec/ChrRacesRec.hpp"
+#include <cstdint>
+
+class ChrRacesRec;
+class ChrClassesRec;
 
 class CGUnit_C {
     public:
         static const char* GetDisplayRaceNameFromRecord(ChrRacesRec* record, uint8_t sexIn, uint8_t* sexOut = nullptr);
+        static const char* GetDisplayClassNameFromRecord(ChrClassesRec* record, uint8_t sexIn, uint8_t* sexOut = nullptr);
 };
 
 #endif // CLIENTOBJECT_UNIT_C_HPP

src/db/rec/BannedAddonsRec.cpp

@@ -0,0 +1,48 @@
+// DO NOT EDIT: generated by whoa-autocode
+#include "db/rec/BannedAddOnsRec.hpp"
+#include "db/Locale.hpp"
+#include "util/SFile.hpp"
+
+const char* BannedAddOnsRec::GetFilename() {
+    return "DBFilesClient\\BannedAddOns.dbc";
+}
+
+uint32_t BannedAddOnsRec::GetNumColumns() {
+    return 11;
+}
+
+uint32_t BannedAddOnsRec::GetRowSize() {
+    return 44;
+}
+
+bool BannedAddOnsRec::NeedIDAssigned() {
+    return false;
+}
+
+int32_t BannedAddOnsRec::GetID() {
+    return this->m_ID;
+}
+
+void BannedAddOnsRec::SetID(int32_t id) {
+    this->m_ID = id;
+}
+
+bool BannedAddOnsRec::Read(SFile* f, const char* stringBuffer) {
+    if (
+        !SFile::Read(f, &this->m_ID, sizeof(this->m_ID), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_nameMd5[0], sizeof(m_nameMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_nameMd5[1], sizeof(m_nameMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_nameMd5[2], sizeof(m_nameMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_nameMd5[3], sizeof(m_nameMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_versionMd5[0], sizeof(m_versionMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_versionMd5[1], sizeof(m_versionMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_versionMd5[2], sizeof(m_versionMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_versionMd5[3], sizeof(m_versionMd5[0]), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_lastModified, sizeof(this->m_lastModified), nullptr, nullptr, nullptr)
+        || !SFile::Read(f, &this->m_flags, sizeof(this->m_flags), nullptr, nullptr, nullptr)
+    ) {
+        return false;
+    }
+
+    return true;
+}

src/db/rec/BannedAddonsRec.hpp

@@ -0,0 +1,26 @@
+// DO NOT EDIT: generated by whoa-autocode
+#ifndef DB_REC_BANNED_ADD_ONS_REC_HPP
+#define DB_REC_BANNED_ADD_ONS_REC_HPP
+
+#include <cstdint>
+
+class SFile;
+
+class BannedAddOnsRec {
+    public:
+        int32_t m_ID;
+        int32_t m_nameMd5[4];
+        int32_t m_versionMd5[4];
+        int32_t m_lastModified;
+        int32_t m_flags;
+
+        static const char* GetFilename();
+        static uint32_t GetNumColumns();
+        static uint32_t GetRowSize();
+        static bool NeedIDAssigned();
+        int32_t GetID();
+        void SetID(int32_t id);
+        bool Read(SFile* f, const char* stringBuffer);
+};
+
+#endif