Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2025-05-30 21:51:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Welp, ended up doing client as well since world and client are in the wroing places.

Browse Source
This commit is contained in:
Aronwk 2025-05-16 00:10:00 -05:00
parent e42df5b02e
commit 3e8a417f62
15 changed files with 459 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dChatServer/ChatPacketHandler.cpp
View File

@ -20,6 +20,7 @@
#include "eGameMasterLevel.h"
#include "ChatPackets.h"
#include "TeamContainer.h"
#include "eChatChannel.h"
void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
//Get from the packet which player we want to do something with:

28
dChatServer/ChatPacketHandler.h
View File

@ -6,33 +6,7 @@
struct PlayerData;
enum class eAddFriendResponseType : uint8_t;
enum class eChatChannel : uint8_t {
SYSTEMNOTIFY = 0,
SYSTEMWARNING,
SYSTEMERROR,
BROADCAST,
LOCAL,
LOCALNOANIM,
EMOTE,
PRIVATE_CHAT,
TEAM,
TEAMLOCAL,
GUILD,
GUILDNOTIFY,
PROPERTY,
ADMIN,
COMBATDAMAGE,
COMBATHEALING,
COMBATLOOT,
COMBATEXP,
COMBATDEATH,
GENERAL,
TRADE,
LFG,
USER
};
enum class eChatChannel : uint8_t;
enum class eChatMessageResponseCode : uint8_t {
SENT = 0,

36
dCommon/dEnums/eChatChannel.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
#ifndef __ECHATCHANNEL__H__
#define __ECHATCHANNEL__H__
#include <cstdint>
enum class eChatChannel : uint8_t {
SYSTEMNOTIFY = 0,
SYSTEMWARNING,
SYSTEMERROR,
BROADCAST,
LOCAL,
LOCALNOANIM,
EMOTE,
PRIVATE_CHAT,
TEAM,
TEAMLOCAL,
GUILD,
GUILDNOTIFY,
PROPERTY,
ADMIN,
COMBATDAMAGE,
COMBATHEALING,
COMBATLOOT,
COMBATEXP,
COMBATDEATH,
GENERAL,
TRADE,
LFG,
USER
};
#endif //!__ECHATCHANNEL__H__

61
dGame/UserManager.cpp
View File

@ -8,7 +8,7 @@
#include "Game.h"
#include "Logger.h"
#include "User.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "Character.h"
#include "BitStream.h"
#include "ObjectIDManager.h"
@ -308,13 +308,17 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
if (!name.empty() && Database::Get()->IsNameInUse(name)) {
LOG("AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
ClientPackets::CharacterCreationResponse response;
response.response = eCharacterCreationResponse::CUSTOM_NAME_IN_USE;
response.Send(sysAddr);
return;
}
if (Database::Get()->IsNameInUse(predefinedName)) {
LOG("AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
ClientPackets::CharacterCreationResponse response;
response.response = eCharacterCreationResponse::PREDEFINED_NAME_IN_USE;
response.Send(sysAddr);
return;
}
@ -328,7 +332,8 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
ObjectIDManager::RequestPersistentID([=, this](uint32_t objectID) {
if (Database::Get()->GetCharacterInfo(objectID)) {
LOG("Character object id unavailable, check object_id_tracker!");
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
ClientPackets::CharacterCreationResponse response;
response.response = eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE;
return;
}
@ -393,8 +398,10 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
//Now finally insert our character xml:
Database::Get()->InsertCharacterXml(objectID, xml.str());
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
ClientPackets::CharacterCreationResponse response;
response.response = eCharacterCreationResponse::SUCCESS;
response.Send(sysAddr);
UserManager::RequestCharacterList(sysAddr);
});
}
@ -419,10 +426,12 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
CheckType::User,
"User %i tried to delete a character that it does not own!",
u->GetAccountID());
ClientPackets::CharacterDeleteResponse response;
if (!hasCharacter) {
WorldPackets::SendCharacterDeleteResponse(sysAddr, false);
response.success = false;
} else {
response.success = true;
LOG("Deleting character %i", charID);
Database::Get()->DeleteCharacter(charID);
@ -430,9 +439,9 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::UNEXPECTED_DISCONNECT);
bitStream.Write(objectID);
Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
WorldPackets::SendCharacterDeleteResponse(sysAddr, true);
}
response.Send(sysAddr);
}
void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet) {
@ -473,32 +482,34 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
return false;
});
ClientPackets::CharacterRenameResponse response;
if (!ownsCharacter || !character) {
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
response.response = eRenameResponse::UNKNOWN_ERROR;
} else if (ownsCharacter && character) {
if (newName == character->GetName()) {
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
return;
}
if (!Database::Get()->GetCharacterInfo(newName)) {
response.response = eRenameResponse::NAME_UNAVAILABLE;
} else if (!Database::Get()->GetCharacterInfo(newName)) {
if (IsNamePreapproved(newName)) {
Database::Get()->SetCharacterName(charID, newName);
LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr);
response.response = eRenameResponse::SUCCESS;
} else {
Database::Get()->SetPendingCharacterName(charID, newName);
LOG("Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr);
response.response = eRenameResponse::SUCCESS;
}
} else {
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
response.response = eRenameResponse::NAME_IN_USE;
}
} else {
LOG("Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
response.response = eRenameResponse::UNKNOWN_ERROR;
}
response.Send(sysAddr);
if (response.response == eRenameResponse::SUCCESS) {
UserManager::RequestCharacterList(sysAddr);
}
}
@ -537,7 +548,11 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
character->SetZoneInstance(zoneInstance);
character->SetZoneClone(zoneClone);
}
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
return;
});
} else {

8
dGame/dBehaviors/PropertyTeleportBehavior.cpp
View File

@ -5,7 +5,7 @@
#include "Character.h"
#include "CharacterComponent.h"
#include "ChatPackets.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "EntityManager.h"
#include "Game.h"
#include "ZoneInstanceManager.h"
@ -55,7 +55,11 @@ void PropertyTeleportBehavior::Handle(BehaviorContext* context, RakNet::BitStrea
entity->GetCharacter()->SaveXMLToDatabase();
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
return;
});
}

8
dGame/dComponents/ActivityComponent.cpp
View File

@ -7,7 +7,7 @@
#include "ZoneInstanceManager.h"
#include "Game.h"
#include "Logger.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "EntityManager.h"
#include "ChatPackets.h"
#include "BitStreamUtils.h"
@ -537,7 +537,11 @@ void ActivityInstance::StartZone() {
player->GetCharacter()->SetZoneClone(zoneClone);
}
WorldPackets::SendTransferToWorld(player->GetSystemAddress(), serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(player->GetSystemAddress());
return;
});
}

9
dGame/dComponents/CharacterComponent.cpp
View File

@ -21,7 +21,7 @@
#include "CDRewardCodesTable.h"
#include "Mail.h"
#include "ZoneInstanceManager.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "MessageType/Game.h"
#include <ctime>
@ -868,8 +868,11 @@ void CharacterComponent::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) const {
character->SaveXMLToDatabase();
}
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
Game::entityManager->DestructEntity(entity);
});
}

8
dGame/dGameMessages/GameMessages.cpp
View File

@ -17,7 +17,7 @@
#include "CppScripts.h"
#include "UserManager.h"
#include "ZoneInstanceManager.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "Item.h"
#include "ZCompression.h"
#include "dConfig.h"
@ -4936,7 +4936,11 @@ void GameMessages::HandleFireEventServerSide(RakNet::BitStream& inStream, Entity
character->SetZoneClone(zoneClone);
}
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
return;
});
}

24
dGame/dUtilities/SlashCommands/DEVGMCommands.cpp
View File

@ -17,7 +17,7 @@
#include "UserManager.h"
#include "User.h"
#include "VanityUtilities.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "ZoneInstanceManager.h"
// Database
@ -73,7 +73,13 @@ namespace DEVGMCommands {
bool success = user->GetMaxGMLevel() >= level;
if (success) {
WorldPackets::SendGMLevelChange(entity->GetSystemAddress(), success, user->GetMaxGMLevel(), entity->GetGMLevel(), level);
ClientPackets::GMLevelChange response;
response.success = success;
response.prevLevel = entity->GetGMLevel();
response.newLevel = level;
response.highestLevel = user->GetMaxGMLevel();
response.Send(entity->GetSystemAddress());
GameMessages::SendChatModeUpdate(entity->GetObjectID(), level);
entity->SetGMLevel(level);
LOG("User %s (%i) has changed their GM level to %i for charID %llu", user->GetUsername().c_str(), user->GetAccountID(), level, entity->GetObjectID());
@ -81,7 +87,13 @@ namespace DEVGMCommands {
#ifndef DEVELOPER_SERVER
if ((entity->GetGMLevel() > user->GetMaxGMLevel()) || (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN && user->GetMaxGMLevel() == eGameMasterLevel::JUNIOR_DEVELOPER)) {
WorldPackets::SendGMLevelChange(entity->GetSystemAddress(), true, user->GetMaxGMLevel(), entity->GetGMLevel(), eGameMasterLevel::CIVILIAN);
ClientPackets::GMLevelChange response;
response.success = false;
response.prevLevel = entity->GetGMLevel();
response.newLevel = eGameMasterLevel::CIVILIAN;
response.highestLevel = user->GetMaxGMLevel();
response.Send(entity->GetSystemAddress());
GameMessages::SendChatModeUpdate(entity->GetObjectID(), eGameMasterLevel::CIVILIAN);
entity->SetGMLevel(eGameMasterLevel::CIVILIAN);
@ -1061,7 +1073,11 @@ namespace DEVGMCommands {
entity->GetCharacter()->SaveXMLToDatabase();
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
return;
});
} else {

14
dGame/dUtilities/SlashCommands/GMZeroCommands.cpp
View File

@ -10,7 +10,7 @@
#include "PlayerManager.h"
#include "SlashCommandHandler.h"
#include "VanityUtilities.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "ZoneInstanceManager.h"
#include "Database.h"
@ -179,7 +179,11 @@ namespace GMZeroCommands {
entity->GetCharacter()->SaveXMLToDatabase();
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
});
}
@ -205,7 +209,11 @@ namespace GMZeroCommands {
entity->GetCharacter()->SaveXMLToDatabase();
WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
ClientPackets::TransferToWorld response;
response.serverIP = serverIP;
response.serverPort = serverPort;
response.mythranShift = mythranShift;
response.Send(sysAddr);
});
}

140
dNet/ClientPackets.cpp
View File

@ -6,6 +6,139 @@
#include "ClientPackets.h"
#include "dCommonVars.h"
#include "PositionUpdate.h"
#include "LDFFormat.h"
#include "ZCompression.h"
namespace ClientPackets {
void LoadStaticZone::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint16_t>(zoneID.GetMapID());
bitStream.Write<uint16_t>(zoneID.GetInstanceID());
bitStream.Write<uint32_t>(checksum);
bitStream.Write<uint8_t>(editorEnabled);
bitStream.Write<uint8_t>(editorLevel);
bitStream.Write(position.x);
bitStream.Write(position.y);
bitStream.Write(position.z);
bitStream.Write<uint32_t>(instanceType);
}
void CharacterCreationResponse::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write(response);
}
void CharacterRenameResponse::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write(response);
}
void CharacterDeleteResponse::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint8_t>(success);
}
void TransferToWorld::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write(LUString(serverIP));
bitStream.Write<uint16_t>(serverPort);
bitStream.Write<uint8_t>(mythranShift);
}
void ServerState::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint8_t>(serverReady);
}
void CreateCharacter::Serialize(RakNet::BitStream &bitStream) const {
RakNet::BitStream data;
data.Write<uint32_t>(7); //LDF key count
std::unique_ptr<LDFData<LWOOBJID>> objidLDF(new LDFData<LWOOBJID>(u"objid", objid));
objidLDF->WriteToPacket(data);
std::unique_ptr<LDFData<LOT>> templateIDLDF(new LDFData<LOT>(u"template", templateID));
templateIDLDF->WriteToPacket(data);
std::unique_ptr<LDFData<std::u16string>> nameLDF(new LDFData<std::u16string>(u"name", name));
nameLDF->WriteToPacket(data);
std::unique_ptr<LDFData<int32_t>> gmlevelLDF(new LDFData<int32_t>(u"gmlevel", static_cast<int32_t>(gmLevel)));
gmlevelLDF->WriteToPacket(data);
std::unique_ptr<LDFData<int32_t>> chatModeLDF(new LDFData<int32_t>(u"chatmode", static_cast<int32_t>(chatMode)));
chatModeLDF->WriteToPacket(data);
std::unique_ptr<LDFData<std::string>> xmlConfigData(new LDFData<std::string>(u"xmlData", xmlData));
xmlConfigData->WriteToPacket(data);
std::unique_ptr<LDFData<int64_t>> reputationLdf(new LDFData<int64_t>(u"reputation", reputation));
reputationLdf->WriteToPacket(data);
//Compress the data before sending:
const uint32_t reservedSize = ZCompression::GetMaxCompressedLength(data.GetNumberOfBytesUsed());
uint8_t* compressedData = new uint8_t[reservedSize];
if (!compressedData) {
throw std::runtime_error("Failed to allocate memory for compressed data");
}
size_t size = ZCompression::Compress(data.GetData(), data.GetNumberOfBytesUsed(), compressedData, reservedSize);
assert(size <= reservedSize);
bitStream.Write<uint32_t>(size + 9); //size of data + header bytes (8)
bitStream.Write<uint8_t>(1); //compressed boolean, true
bitStream.Write<uint32_t>(data.GetNumberOfBytesUsed());
bitStream.Write<uint32_t>(size);
/**
* In practice, this warning serves no purpose for us. We allocate the max memory needed on the heap
* and then compress the data. In the off chance that the compression actually increases the size,
* an assertion is done to prevent bad data from being saved or sent.
*/
#pragma warning(disable:6385) // C6385 Reading invalid data from 'compressedData'.
bitStream.WriteAlignedBytes(compressedData, size);
#pragma warning(default:6385)
delete[] compressedData;
};
void ChatModerationString::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint8_t>(rejectedWords.empty()); // Accepted
bitStream.Write<uint16_t>(0); // padding
bitStream.Write(chatChannel);
bitStream.Write(chatMode);
bitStream.Write(LUWString(receiver, 42));
for (auto it : rejectedWords) {
bitStream.Write<uint8_t>(it.first); // start index
bitStream.Write<uint8_t>(it.second); // length
}
// Pad out the rest of the packet
// The client expects 64 items, so we need to write 64 - rejectedWords.size() empty items
for (int i = rejectedWords.size(); 64 > i; i++) {
bitStream.Write<uint16_t>(0);
}
}
void GMLevelChange::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint8_t>(success);
bitStream.Write(static_cast<uint16_t>(highestLevel));
bitStream.Write(static_cast<uint16_t>(prevLevel));
bitStream.Write(static_cast<uint16_t>(newLevel));
}
void DebugOutput::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint32_t>(data.size());
bitStream.Write(data);
}
void HTTPMonitorInfoResponse::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write<uint16_t>(port);
bitStream.Write<uint8_t>(openWeb);
bitStream.Write<uint8_t>(supportsSum);
bitStream.Write<uint8_t>(supportsDetail);
bitStream.Write<uint8_t>(supportsWho);
bitStream.Write<uint8_t>(supportsObjects);
}
}
ChatMessage ClientPackets::HandleChatMessage(Packet* packet) {
CINSTREAM_SKIP_HEADER;
@ -114,10 +247,3 @@ ChatModerationRequest ClientPackets::HandleChatModerationRequest(Packet* packet)
return request;
}
int32_t ClientPackets::SendTop5HelpIssues(Packet* packet) {
CINSTREAM_SKIP_HEADER;
int32_t language = 0;
inStream.Read(language);
return language;
}

113
dNet/ClientPackets.h
View File

@ -8,6 +8,10 @@
#include <cstdint>
#include <string>
#include "BitStreamUtils.h"
#include "eGameMasterLevel.h"
#include "eChatChannel.h"
#include "dCommonVars.h"
class PositionUpdate;
@ -26,11 +30,118 @@ struct ChatModerationRequest {
std::string message;
};
class User;
struct SystemAddress;
enum class eCharacterCreationResponse : uint8_t;
enum class eRenameResponse : uint8_t;
namespace ClientPackets {
ChatMessage HandleChatMessage(Packet* packet);
PositionUpdate HandleClientPositionUpdate(Packet* packet);
ChatModerationRequest HandleChatModerationRequest(Packet* packet);
int32_t SendTop5HelpIssues(Packet* packet);
struct LoadStaticZone : public LUBitStream {
LWOZONEID zoneID;
uint32_t checksum = 0;
bool editorEnabled = false;
uint8_t editorLevel = 0;
NiPoint3 position = NiPoint3Constant::ZERO;
uint32_t instanceType = 0;
LoadStaticZone() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::LOAD_STATIC_ZONE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct CharacterCreationResponse : public LUBitStream {
eCharacterCreationResponse response;
CharacterCreationResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHARACTER_CREATE_RESPONSE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct CharacterRenameResponse : public LUBitStream {
eRenameResponse response;
CharacterRenameResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHARACTER_RENAME_RESPONSE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct CharacterDeleteResponse : public LUBitStream {
bool success;
CharacterDeleteResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::DELETE_CHARACTER_RESPONSE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct TransferToWorld : public LUBitStream {
std::string serverIP;
uint32_t serverPort = 0;
bool mythranShift = false;
TransferToWorld() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::TRANSFER_TO_WORLD) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct ServerState : public LUBitStream {
bool serverReady = false;
ServerState() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::SERVER_STATES) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct CreateCharacter : public LUBitStream {
LWOOBJID objid = 0;
LOT templateID = 1;
std::u16string name;
eGameMasterLevel gmLevel = eGameMasterLevel::CIVILIAN;
int32_t chatMode = 0;
std::string xmlData;
int64_t reputation = 0;
CreateCharacter() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CREATE_CHARACTER) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct ChatModerationString : public LUBitStream {
eChatChannel chatChannel = eChatChannel::SYSTEMNOTIFY;
uint8_t chatMode = 0;
std::string receiver;
std::set<std::pair<uint8_t, uint8_t>> rejectedWords;
ChatModerationString() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHAT_MODERATION_STRING) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct GMLevelChange : public LUBitStream {
bool success = false;
eGameMasterLevel highestLevel = eGameMasterLevel::CIVILIAN;
eGameMasterLevel prevLevel = eGameMasterLevel::CIVILIAN;
eGameMasterLevel newLevel = eGameMasterLevel::CIVILIAN;
GMLevelChange() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::MAKE_GM_RESPONSE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct DebugOutput : public LUBitStream {
std::string data;
DebugOutput() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::DEBUG_OUTPUT) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct HTTPMonitorInfoResponse : public LUBitStream {
uint16_t port = 80;
bool openWeb = false;
bool supportsSum = false;
bool supportsDetail = false;
bool supportsWho = false;
bool supportsObjects = false;
HTTPMonitorInfoResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::HTTP_MONITOR_INFO_RESPONSE) {};
void Serialize(RakNet::BitStream& bitStream) const override;
};
};
#endif // CLIENTPACKETS_H

214
dNet/WorldPackets.cpp
View File

@ -1,186 +1,42 @@
#include "WorldPackets.h"
#include "dCommonVars.h"
#include "BitStream.h"
#include "GeneralUtils.h"
#include "Logger.h"
#include "Game.h"
#include "LDFFormat.h"
#include "dServer.h"
#include "ZCompression.h"
#include "eConnectionType.h"
#include "BitStreamUtils.h"
#include "Amf3.h"
#include "dConfig.h"
#include "GameMessages.h"
#include "Entity.h"
#include <iostream>
void HTTPMonitorInfo::Serialize(RakNet::BitStream &bitStream) const {
bitStream.Write(port);
bitStream.Write<uint8_t>(openWeb);
bitStream.Write<uint8_t>(supportsSum);
bitStream.Write<uint8_t>(supportsDetail);
bitStream.Write<uint8_t>(supportsWho);
bitStream.Write<uint8_t>(supportsObjects);
}
void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::LOAD_STATIC_ZONE);
bitStream.Write<uint16_t>(zone.GetMapID());
bitStream.Write<uint16_t>(zone.GetInstanceID());
//bitStream.Write<uint32_t>(zone.GetCloneID());
bitStream.Write(0);
bitStream.Write(checksum);
bitStream.Write<uint16_t>(0); // ??
bitStream.Write(x);
bitStream.Write(y);
bitStream.Write(z);
bitStream.Write<uint32_t>(0); // Change this to eventually use 4 on activity worlds
SEND_PACKET;
}
void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHARACTER_CREATE_RESPONSE);
bitStream.Write(response);
SEND_PACKET;
}
void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHARACTER_RENAME_RESPONSE);
bitStream.Write(response);
SEND_PACKET;
}
void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::DELETE_CHARACTER_RESPONSE);
bitStream.Write<uint8_t>(response);
SEND_PACKET;
}
void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::TRANSFER_TO_WORLD);
bitStream.Write(LUString(serverIP));
bitStream.Write<uint16_t>(serverPort);
bitStream.Write<uint8_t>(mythranShift);
SEND_PACKET;
}
void WorldPackets::SendServerState(const SystemAddress& sysAddr) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::SERVER_STATES);
bitStream.Write<uint8_t>(1); //If the server is receiving this request, it probably is ready anyway.
SEND_PACKET;
}
void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, int64_t reputation, LWOOBJID player, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CREATE_CHARACTER);
RakNet::BitStream data;
data.Write<uint32_t>(7); //LDF key count
std::unique_ptr<LDFData<LWOOBJID>> objid(new LDFData<LWOOBJID>(u"objid", player));
std::unique_ptr<LDFData<LOT>> lot(new LDFData<LOT>(u"template", 1));
std::unique_ptr<LDFData<std::string>> xmlConfigData(new LDFData<std::string>(u"xmlData", xmlData));
std::unique_ptr<LDFData<std::u16string>> name(new LDFData<std::u16string>(u"name", username));
std::unique_ptr<LDFData<int32_t>> gmlevel(new LDFData<int32_t>(u"gmlevel", static_cast<int32_t>(gm)));
std::unique_ptr<LDFData<int32_t>> chatmode(new LDFData<int32_t>(u"chatmode", static_cast<int32_t>(gm)));
std::unique_ptr<LDFData<int64_t>> reputationLdf(new LDFData<int64_t>(u"reputation", reputation));
objid->WriteToPacket(data);
lot->WriteToPacket(data);
name->WriteToPacket(data);
gmlevel->WriteToPacket(data);
chatmode->WriteToPacket(data);
xmlConfigData->WriteToPacket(data);
reputationLdf->WriteToPacket(data);
//Compress the data before sending:
const uint32_t reservedSize = ZCompression::GetMaxCompressedLength(data.GetNumberOfBytesUsed());
uint8_t* compressedData = new uint8_t[reservedSize];
// TODO There should be better handling here for not enough memory...
if (!compressedData) return;
size_t size = ZCompression::Compress(data.GetData(), data.GetNumberOfBytesUsed(), compressedData, reservedSize);
assert(size <= reservedSize);
bitStream.Write<uint32_t>(size + 9); //size of data + header bytes (8)
bitStream.Write<uint8_t>(1); //compressed boolean, true
bitStream.Write<uint32_t>(data.GetNumberOfBytesUsed());
bitStream.Write<uint32_t>(size);
/**
* In practice, this warning serves no purpose for us. We allocate the max memory needed on the heap
* and then compress the data. In the off chance that the compression actually increases the size,
* an assertion is done to prevent bad data from being saved or sent.
*/
#pragma warning(disable:6385) // C6385 Reading invalid data from 'compressedData'.
bitStream.WriteAlignedBytes(compressedData, size);
#pragma warning(default:6385)
SEND_PACKET;
delete[] compressedData;
LOG("Sent CreateCharacter for ID: %llu", player);
}
void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::set<std::pair<uint8_t, uint8_t>> unacceptedItems) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHAT_MODERATION_STRING);
bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
bitStream.Write<uint16_t>(0x16); // Source ID, unknown
bitStream.Write<uint8_t>(requestID); // request ID
bitStream.Write<char>(0); // chat mode
bitStream.Write(LUWString(receiver, 42)); // receiver name
for (auto it : unacceptedItems) {
bitStream.Write<uint8_t>(it.first); // start index
bitStream.Write<uint8_t>(it.second); // length
namespace WorldPackets {
bool UIHelpTop5::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(languageCode));
return true;
}
for (int i = unacceptedItems.size(); 64 > i; i++) {
bitStream.Write<uint16_t>(0);
void UIHelpTop5::Handle() {
AMFArrayValue data;
switch (languageCode) {
case eLanguageCodeID::EN_US:
// Summaries
data.Insert("Summary0", Game::config->GetValue("help_0_summary"));
data.Insert("Summary1", Game::config->GetValue("help_1_summary"));
data.Insert("Summary2", Game::config->GetValue("help_2_summary"));
data.Insert("Summary3", Game::config->GetValue("help_3_summary"));
data.Insert("Summary4", Game::config->GetValue("help_4_summary"));
// Descriptions
data.Insert("Description0", Game::config->GetValue("help_0_description"));
data.Insert("Description1", Game::config->GetValue("help_1_description"));
data.Insert("Description2", Game::config->GetValue("help_2_description"));
data.Insert("Description3", Game::config->GetValue("help_3_description"));
data.Insert("Description4", Game::config->GetValue("help_4_description"));
break;
case eLanguageCodeID::PL_US:
case eLanguageCodeID::DE_DE:
case eLanguageCodeID::EN_GB:
default:
break;
}
GameMessages::SendUIMessageServerToSingleClient(player, sysAddr, "UIHelpTop5", data);
}
SEND_PACKET;
}
void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAKE_GM_RESPONSE);
bitStream.Write<uint8_t>(success);
bitStream.Write(static_cast<uint16_t>(highestLevel));
bitStream.Write(static_cast<uint16_t>(prevLevel));
bitStream.Write(static_cast<uint16_t>(newLevel));
SEND_PACKET;
}
void WorldPackets::SendHTTPMonitorInfo(const SystemAddress& sysAddr, const HTTPMonitorInfo& info) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::HTTP_MONITOR_INFO_RESPONSE);
info.Serialize(bitStream);
SEND_PACKET;
}
void WorldPackets::SendDebugOuput(const SystemAddress& sysAddr, const std::string& data){
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::DEBUG_OUTPUT);
bitStream.Write<uint32_t>(data.size());
bitStream.Write(data);
SEND_PACKET;
}

50
dNet/WorldPackets.h
View File

@ -2,40 +2,30 @@
#define WORLDPACKETS_H
#include "dCommonVars.h"
#include <vector>
#include <string>
#include "BitStreamUtils.h"
#include "MessageType/World.h"
class User;
struct SystemAddress;
enum class eGameMasterLevel : uint8_t;
enum class eCharacterCreationResponse : uint8_t;
enum class eRenameResponse : uint8_t;
namespace RakNet {
class BitStream;
};
struct HTTPMonitorInfo {
uint16_t port = 80;
bool openWeb = false;
bool supportsSum = false;
bool supportsDetail = false;
bool supportsWho = false;
bool supportsObjects = false;
void Serialize(RakNet::BitStream &bitstream) const;
class Entity;
enum class eLanguageCodeID : int32_t {
EN_US = 0,
PL_US = 1,
DE_DE = 2,
EN_GB = 3
};
namespace WorldPackets {
void SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone);
void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);
void SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response);
void SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift);
void SendServerState(const SystemAddress& sysAddr);
void SendCreateCharacter(const SystemAddress& sysAddr, int64_t reputation, LWOOBJID player, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm);
void SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::set<std::pair<uint8_t, uint8_t>> unacceptedItems);
void SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel);
void SendHTTPMonitorInfo(const SystemAddress& sysAddr, const HTTPMonitorInfo& info);
void SendDebugOuput(const SystemAddress& sysAddr, const std::string& data);
struct UIHelpTop5: public LUBitStream {
eLanguageCodeID languageCode = eLanguageCodeID::EN_US;
// should these be shoved up to the base class?
SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
Entity* player = nullptr;
UIHelpTop5() : LUBitStream(eConnectionType::WORLD, MessageType::World::UI_HELP_TOP_5) {};
bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override;
};
}
#endif // WORLDPACKETS_H

64
dWorldServer/WorldServer.cpp
View File

@ -31,6 +31,7 @@
#include "AuthPackets.h"
#include "BitStreamUtils.h"
#include "WorldPackets.h"
#include "ClientPackets.h"
#include "UserManager.h"
#include "CDClientManager.h"
#include "CDClientDatabase.h"
@ -715,18 +716,15 @@ void HandleMasterPacket(Packet* packet) {
auto zone = Game::zoneManager->GetZone();
if (zone) {
float x = 0.0f;
float y = 0.0f;
float z = 0.0f;
NiPoint3 pos = NiPoint3Constant::ZERO;
if (zone->GetZoneID().GetMapID() == 1100) {
auto pos = zone->GetSpawnPos();
x = pos.x;
y = pos.y;
z = pos.z;
pos = zone->GetSpawnPos();
}
WorldPackets::SendLoadStaticZone(it->second.sysAddr, x, y, z, zone->GetChecksum(), Game::zoneManager->GetZoneID());
ClientPackets::LoadStaticZone load;
load.zoneID = Game::zoneManager->GetZoneID();
load.checksum = zone->GetChecksum();
load.position = pos;
}
if (Game::server->GetZoneID() == 0) {
@ -1040,8 +1038,17 @@ void HandlePacket(Packet* packet) {
auto* characterComponent = player->GetComponent<CharacterComponent>();
if (!characterComponent) return;
WorldPackets::SendCreateCharacter(packet->systemAddress, player->GetComponent<CharacterComponent>()->GetReputation(), player->GetObjectID(), c->GetXMLData(), username, c->GetGMLevel());
WorldPackets::SendServerState(packet->systemAddress);
ClientPackets::CreateCharacter createCharacter;
createCharacter.objid = player->GetObjectID();
createCharacter.name = username;
createCharacter.gmLevel = c->GetGMLevel();
createCharacter.xmlData = c->GetXMLData();
createCharacter.reputation = player->GetComponent<CharacterComponent>()->GetReputation();
createCharacter.Send(packet->systemAddress);
ClientPackets::ServerState serverState;
serverState.serverReady = true;
serverState.Send(packet->systemAddress);
const auto respawnPoint = player->GetCharacter()->GetRespawnPoint(Game::zoneManager->GetZone()->GetWorldID());
@ -1336,7 +1343,10 @@ void HandlePacket(Packet* packet) {
}
user->SetLastChatMessageApproved(bAllClean);
WorldPackets::SendChatModerationResponse(packet->systemAddress, bAllClean, request.requestID, request.receiver, segments);
ClientPackets::ChatModerationString response;
response.receiver = request.receiver;
response.rejectedWords = segments;
response.Send(packet->systemAddress);
break;
}
@ -1392,13 +1402,8 @@ void HandlePacket(Packet* packet) {
case MessageType::World::UI_HELP_TOP_5: {
auto language = ClientPackets::SendTop5HelpIssues(packet);
// TODO: Handle different languages in a nice way
// 0: en_US
// 1: pl_US
// 2: de_DE
// 3: en_GB
WorldPackets::UIHelpTop5 help;
help.Deserialize(inStream);
// TODO: Find a good home for the logic in this case.
auto* user = UserManager::Instance()->GetUser(packet->systemAddress);
if (!user) return;
@ -1406,23 +1411,10 @@ void HandlePacket(Packet* packet) {
if (!character) return;
auto* entity = character->GetEntity();
if (!entity) return;
AMFArrayValue data;
// Summaries
data.Insert("Summary0", Game::config->GetValue("help_0_summary"));
data.Insert("Summary1", Game::config->GetValue("help_1_summary"));
data.Insert("Summary2", Game::config->GetValue("help_2_summary"));
data.Insert("Summary3", Game::config->GetValue("help_3_summary"));
data.Insert("Summary4", Game::config->GetValue("help_4_summary"));
// Descriptions
data.Insert("Description0", Game::config->GetValue("help_0_description"));
data.Insert("Description1", Game::config->GetValue("help_1_description"));
data.Insert("Description2", Game::config->GetValue("help_2_description"));
data.Insert("Description3", Game::config->GetValue("help_3_description"));
data.Insert("Description4", Game::config->GetValue("help_4_description"));
GameMessages::SendUIMessageServerToSingleClient(entity, packet->systemAddress, "UIHelpTop5", data);
help.sysAddr = packet->systemAddress;
help.player = entity;
help.Handle();
break;
}