DrSocalkwe3n/LuaVox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Синхронизация профилей контента

Browse Source
This commit is contained in:
DrSocalkwe3n
2026-01-17 18:59:36 +03:00
parent affdc75ebd
commit 3fb06080db
14 changed files with 1120 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
Src/Client/Abstract.hpp
View File

@@ -1,9 +1,13 @@
#pragma once
#include "Common/Net.hpp"
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
#include <Common/Abstract.hpp>
@@ -149,14 +153,6 @@ struct WorldInfo {
std::unordered_map<Pos::GlobalRegion, Region> Regions;
};
struct VoxelInfo {
};
struct NodeInfo {
};
struct PortalInfo {
};
@@ -168,19 +164,77 @@ struct EntityInfo {
glm::quat Quat = glm::quat(1.f, 0.f, 0.f, 0.f);
};
struct FuncEntityInfo {
/*
Конструируются с серверными идентификаторами
*/
struct DefVoxel {
DefVoxel() = default;
DefVoxel(const std::u8string_view view) {
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
}
};
struct DefItemInfo {
struct DefNode {
std::variant<AssetsNodestate> RenderStates;
DefNode() = default;
DefNode(const std::u8string_view view) {
Net::LinearReader lr(view);
RenderStates = lr.read<uint32_t>();
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
RenderStates = am(EnumAssets::Nodestate, std::get<AssetsNodestate>(RenderStates));
}
};
struct DefVoxel_t {};
struct DefNode_t {
AssetsNodestate NodestateId = 0;
AssetsTexture TexId = 0;
struct DefWorld {
DefWorld() = default;
DefWorld(const std::u8string_view view) {
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
}
};
struct DefPortal {
DefPortal() = default;
DefPortal(const std::u8string_view view) {
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
}
};
struct DefEntity {
DefEntity() = default;
DefEntity(const std::u8string_view view) {
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
}
};
struct DefItem {
DefItem() = default;
DefItem(const std::u8string_view view) {
}
void reBind(const std::function<ResourceId(EnumAssets, ResourceId)>& am) {
}
};
struct AssetEntry {
@@ -217,12 +271,12 @@ public:
// Используемые профили контента
struct {
std::unordered_map<DefVoxelId, DefVoxel_t> DefVoxel;
std::unordered_map<DefNodeId, DefNode_t> DefNode;
std::unordered_map<DefWorldId, DefWorldInfo> DefWorld;
std::unordered_map<DefPortalId, DefPortalInfo> DefPortal;
std::unordered_map<DefEntityId, DefEntityInfo> DefEntity;
std::unordered_map<DefItemId, DefItemInfo> DefItem;
std::unordered_map<DefVoxelId, DefVoxel> DefVoxels;
std::unordered_map<DefNodeId, DefNode> DefNodes;
std::unordered_map<DefWorldId, DefWorld> DefWorlds;
std::unordered_map<DefPortalId, DefPortal> DefPortals;
std::unordered_map<DefEntityId, DefEntity> DefEntitys;
std::unordered_map<DefItemId, DefItem> DefItems;
} Profiles;
// Видимый контент

16
Src/Client/AssetsManager.hpp
View File

@@ -46,7 +46,11 @@ public:
public:
AssetsManager(asio::io_context& ioc, fs::path cachePath)
: Cache(AssetsCacheManager::Create(ioc, cachePath)) {
: Cache(AssetsCacheManager::Create(ioc, cachePath))
{
for(size_t type = 0; type < static_cast<size_t>(EnumAssets::MAX_ENUM); type++) {
ServerToClientMap[type].push_back(0);
}
}
// Ручные обновления
@@ -179,9 +183,13 @@ public:
) {
LOG.debug() << "BindDK domains=" << domains.size();
for(size_t type = 0; type < static_cast<size_t>(EnumAssets::MAX_ENUM); ++type) {
LOG.info() << type;
for(size_t forDomainIter = 0; forDomainIter < keys[type].size(); ++forDomainIter) {
LOG.info() << "\t" << domains[forDomainIter];
for(const std::string& key : keys[type][forDomainIter]) {
ServerToClientMap[type].push_back(getId((EnumAssets) type, domains[forDomainIter], key));
uint32_t id = getId((EnumAssets) type, domains[forDomainIter], key);
LOG.info() << "\t\t" << key << " -> " << id;
ServerToClientMap[type].push_back(id);
}
}
}
@@ -299,6 +307,10 @@ public:
return std::move(RU);
}
ResourceId reBind(EnumAssets type, ResourceId server) {
return ServerToClientMap[static_cast<size_t>(type)].at(server);
}
void tick() {
// Проверим кеш
std::vector<std::pair<Hash_t, std::optional<Resource>>> resources = Cache->pullReads();

384
Src/Client/ServerSession.cpp
View File

@@ -17,6 +17,7 @@
#include <Common/Packets.hpp>
#include <glm/ext.hpp>
#include <optional>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
@@ -65,12 +66,6 @@ ServerSession::ServerSession(asio::io_context &ioc, std::unique_ptr<Net::AsyncSo
{
assert(Socket.get());
Profiles.DefNode[0] = {0};
Profiles.DefNode[1] = {1};
Profiles.DefNode[2] = {2};
Profiles.DefNode[3] = {3};
Profiles.DefNode[4] = {4};
try {
asio::co_spawn(ioc, run(AUC.use()), asio::detached);
// TODO: добавить оптимизацию для подключения клиента к внутреннему серверу
@@ -345,18 +340,19 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
// Перевариваем данные по тактам
// Профили
std::unordered_map<DefVoxelId, void*> profile_Voxel_AddOrChange;
std::unordered_map<DefVoxelId, DefVoxel> profile_Voxel_AddOrChange;
std::vector<DefVoxelId> profile_Voxel_Lost;
std::unordered_map<DefNodeId, DefNode_t> profile_Node_AddOrChange;
std::unordered_map<DefNodeId, DefNode> profile_Node_AddOrChange;
std::vector<DefNodeId> profile_Node_Lost;
std::unordered_map<DefWorldId, void*> profile_World_AddOrChange;
std::unordered_map<DefWorldId, DefWorld> profile_World_AddOrChange;
std::vector<DefWorldId> profile_World_Lost;
std::unordered_map<DefPortalId, void*> profile_Portal_AddOrChange;
std::unordered_map<DefPortalId, DefPortal> profile_Portal_AddOrChange;
std::vector<DefPortalId> profile_Portal_Lost;
std::unordered_map<DefEntityId, DefEntityInfo> profile_Entity_AddOrChange;
std::unordered_map<DefEntityId, DefEntity> profile_Entity_AddOrChange;
std::vector<DefEntityId> profile_Entity_Lost;
std::unordered_map<DefItemId, void*> profile_Item_AddOrChange;
std::unordered_map<DefItemId, DefItem> profile_Item_AddOrChange;
std::vector<DefItemId> profile_Item_Lost;
std::unordered_map<EntityId_t, EntityInfo> entity_AddOrChange;
std::vector<EntityId_t> entity_Lost;
@@ -382,6 +378,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_Voxel_Lost.end() && *iter == id)
profile_Voxel_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_Voxel_AddOrChange[id] = profile;
}
@@ -401,6 +403,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_Node_Lost.end() && *iter == id)
profile_Node_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_Node_AddOrChange[id] = profile;
}
@@ -420,6 +428,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_World_Lost.end() && *iter == id)
profile_World_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_World_AddOrChange[id] = profile;
}
@@ -439,6 +453,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_Portal_Lost.end() && *iter == id)
profile_Portal_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_Portal_AddOrChange[id] = profile;
}
@@ -458,6 +478,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_Entity_Lost.end() && *iter == id)
profile_Entity_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_Entity_AddOrChange[id] = profile;
}
@@ -477,6 +503,12 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
if(iter != profile_Item_Lost.end() && *iter == id)
profile_Item_Lost.erase(iter);
profile.reBind(
[&](EnumAssets type, ResourceId server) {
return AM.reBind(type, server);
}
);
profile_Item_AddOrChange[id] = profile;
}
@@ -657,7 +689,6 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
for(auto& [wId, regions] : regions_Lost_Result)
result.Chunks_Lost[wId] = std::vector<Pos::GlobalRegion>(regions.begin(), regions.end());
{
for(TickData& data : ticks) {
}
@@ -669,12 +700,23 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
// Применяем изменения по ресурсам, профилям и контенту
// Определения
{
for(auto& [resId, def] : profile_Node_AddOrChange) {
Profiles.DefNode[resId] = def;
}
for(auto& [resId, def] : profile_Entity_AddOrChange) {
Profiles.DefEntity[resId] = def;
}
for(auto& [resId, def] : profile_Voxel_AddOrChange)
Profiles.DefVoxels[resId] = def;
for(auto& [resId, def] : profile_Node_AddOrChange)
Profiles.DefNodes[resId] = def;
for(auto& [resId, def] : profile_World_AddOrChange)
Profiles.DefWorlds[resId] = def;
for(auto& [resId, def] : profile_Portal_AddOrChange)
Profiles.DefPortals[resId] = def;
for(auto& [resId, def] : profile_Entity_AddOrChange)
Profiles.DefEntitys[resId] = def;
for(auto& [resId, def] : profile_Item_AddOrChange)
Profiles.DefItems[resId] = def;
}
// Чанки
@@ -724,7 +766,6 @@ void ServerSession::update(GlobalTime gTime, float dTime) {
regions[pos >> 2].Chunks[Pos::bvec4u(pos & 0x3).pack()].Nodes = std::move(data);
}
}
}
// Сущности
@@ -904,6 +945,9 @@ coro<> ServerSession::readPacket(Net::AsyncSocket &sock) {
case ToClient::AssetsNextSend:
co_await rP_AssetsNextSend(sock);
co_return;
case ToClient::DefinitionsFull:
co_await rP_DefinitionsFull(sock);
co_return;
case ToClient::DefinitionsUpdate:
co_await rP_DefinitionsUpdate(sock);
co_return;
@@ -1035,55 +1079,281 @@ coro<> ServerSession::rP_AssetsNextSend(Net::AsyncSocket &sock) {
AsyncContext.AssetsLoading.erase(AsyncContext.AssetsLoading.find(hash));
}
coro<> ServerSession::rP_DefinitionsFull(Net::AsyncSocket &sock) {
std::vector<ResourceId> ids;
uint32_t size = 0;
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.emplace_back(
ids[iter],
DefVoxel{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.emplace_back(
ids[iter],
DefNode{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_World_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_World_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_World_AddOrChange.emplace_back(
ids[iter],
DefWorld{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.emplace_back(
ids[iter],
DefPortal{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.emplace_back(
ids[iter],
DefEntity{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);}
}
{
size = co_await sock.read<uint32_t>();
ids.clear();
ids.reserve(size);
for(size_t iter = 0; iter < size; iter++) {
ids.push_back(co_await sock.read<uint32_t>());
}
AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; iter++) {
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.emplace_back(
ids[iter],
DefItem{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
size = co_await sock.read<uint32_t>();
for(size_t iter = 0; iter < size; iter++) {
std::string domain = co_await sock.read<std::string>();
std::string key = co_await sock.read<std::string>();
(void) domain;
(void) key;
}
}
}
coro<> ServerSession::rP_DefinitionsUpdate(Net::AsyncSocket &sock) {
static std::atomic<uint32_t> debugDefLogCount = 0;
uint32_t typeCount = co_await sock.read<uint32_t>();
typeCount = std::min<uint32_t>(typeCount, static_cast<uint32_t>(EnumDefContent::MAX_ENUM));
uint32_t size;
for(uint32_t type = 0; type < typeCount; ++type) {
uint32_t count = co_await sock.read<uint32_t>();
for(uint32_t i = 0; i < count; ++i) {
ResourceId id = co_await sock.read<ResourceId>();
std::string dataStr = co_await sock.read<std::string>();
(void)dataStr;
if(type == static_cast<uint32_t>(EnumDefContent::Node)) {
DefNode_t def;
def.NodestateId = 0;
def.TexId = id;
AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.emplace_back(id, def);
if(id < 32) {
uint32_t idx = debugDefLogCount.fetch_add(1);
if(idx < 64) {
LOG.debug() << "DefNode id=" << id
<< " nodestate=" << def.NodestateId
<< " tex=" << def.TexId;
}
}
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Voxel_AddOrChange.emplace_back(
id,
DefVoxel{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
uint32_t lostCount = co_await sock.read<uint32_t>();
lostCount = std::min<uint32_t>(lostCount, static_cast<uint32_t>(EnumDefContent::MAX_ENUM));
for(uint32_t type = 0; type < lostCount; ++type) {
uint32_t count = co_await sock.read<uint32_t>();
for(uint32_t i = 0; i < count; ++i) {
ResourceId id = co_await sock.read<ResourceId>();
if(type == static_cast<uint32_t>(EnumDefContent::Node))
AsyncContext.ThisTickEntry.Profile_Node_Lost.push_back(id);
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Node_AddOrChange.emplace_back(
id,
DefNode{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
uint32_t dkCount = co_await sock.read<uint32_t>();
dkCount = std::min<uint32_t>(dkCount, static_cast<uint32_t>(EnumDefContent::MAX_ENUM));
for(uint32_t type = 0; type < dkCount; ++type) {
uint32_t count = co_await sock.read<uint32_t>();
for(uint32_t i = 0; i < count; ++i) {
std::string key = co_await sock.read<std::string>();
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_World_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_World_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_World_AddOrChange.emplace_back(
id,
DefWorld{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Portal_AddOrChange.emplace_back(
id,
DefPortal{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Entity_AddOrChange.emplace_back(
id,
DefEntity{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.reserve(AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.size()+size);
for(size_t iter = 0; iter < size; ++iter) {
uint32_t id = co_await sock.read<uint32_t>();
std::string data = co_await sock.read<std::string>();
AsyncContext.ThisTickEntry.Profile_Item_AddOrChange.emplace_back(
id,
DefItem{
std::u8string_view((const char8_t*) data.data(), data.size())
}
);
}
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_Voxel_Lost.push_back(co_await sock.read<ResourceId>());
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_Node_Lost.push_back(co_await sock.read<ResourceId>());
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_World_Lost.push_back(co_await sock.read<ResourceId>());
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_Portal_Lost.push_back(co_await sock.read<ResourceId>());
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_Entity_Lost.push_back(co_await sock.read<ResourceId>());
}
{
size = co_await sock.read<uint32_t>();
for(uint32_t iter = 0; iter < size; ++iter)
AsyncContext.ThisTickEntry.Profile_Item_Lost.push_back(co_await sock.read<ResourceId>());
}
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
size = co_await sock.read<uint32_t>();
for(size_t iter = 0; iter < size; iter++) {
std::string domain = co_await sock.read<std::string>();
(void)key;
std::string key = co_await sock.read<std::string>();
(void) domain;
(void) key;
}
}

13
Src/Client/ServerSession.hpp
View File

@@ -122,17 +122,17 @@ private:
// Полученные с сервера ресурсы
std::vector<std::tuple<ResourceFile::Hash_t, std::u8string>> ReceivedAssets;
std::vector<std::pair<DefVoxelId, void*>> Profile_Voxel_AddOrChange;
std::vector<std::pair<DefVoxelId, DefVoxel>> Profile_Voxel_AddOrChange;
std::vector<DefVoxelId> Profile_Voxel_Lost;
std::vector<std::pair<DefNodeId, DefNode_t>> Profile_Node_AddOrChange;
std::vector<std::pair<DefNodeId, DefNode>> Profile_Node_AddOrChange;
std::vector<DefNodeId> Profile_Node_Lost;
std::vector<std::pair<DefWorldId, void*>> Profile_World_AddOrChange;
std::vector<std::pair<DefWorldId, DefWorld>> Profile_World_AddOrChange;
std::vector<DefWorldId> Profile_World_Lost;
std::vector<std::pair<DefPortalId, void*>> Profile_Portal_AddOrChange;
std::vector<std::pair<DefPortalId, DefPortal>> Profile_Portal_AddOrChange;
std::vector<DefPortalId> Profile_Portal_Lost;
std::vector<std::pair<DefEntityId, DefEntityInfo>> Profile_Entity_AddOrChange;
std::vector<std::pair<DefEntityId, DefEntity>> Profile_Entity_AddOrChange;
std::vector<DefEntityId> Profile_Entity_Lost;
std::vector<std::pair<DefItemId, void*>> Profile_Item_AddOrChange;
std::vector<std::pair<DefItemId, DefItem>> Profile_Item_AddOrChange;
std::vector<DefItemId> Profile_Item_Lost;
std::vector<std::pair<WorldId_t, void*>> Worlds_AddOrChange;
@@ -197,6 +197,7 @@ private:
coro<> rP_AssetsBindHH(Net::AsyncSocket &sock);
coro<> rP_AssetsInitSend(Net::AsyncSocket &sock);
coro<> rP_AssetsNextSend(Net::AsyncSocket &sock);
coro<> rP_DefinitionsFull(Net::AsyncSocket &sock);
coro<> rP_DefinitionsUpdate(Net::AsyncSocket &sock);
coro<> rP_ChunkVoxels(Net::AsyncSocket &sock);
coro<> rP_ChunkNodes(Net::AsyncSocket &sock);

127
Src/Client/Vulkan/VulkanRenderSession.cpp
View File

@@ -121,15 +121,15 @@ void ChunkMeshGenerator::run(uint8_t id) {
uint8_t fullNodes[18][18][18];
// Профиль, который используется если на стороне клиента отсутствует нужных профиль
DefNode_t defaultProfileNode;
DefNode defaultProfileNode;
// Кеш запросов профилей нод
std::unordered_map<DefNodeId, const DefNode_t*> profilesNodeCache;
auto getNodeProfile = [&](DefNodeId id) -> const DefNode_t* {
std::unordered_map<DefNodeId, const DefNode*> profilesNodeCache;
auto getNodeProfile = [&](DefNodeId id) -> const DefNode* {
auto iterCache = profilesNodeCache.find(id);
if(iterCache == profilesNodeCache.end()) {
// Промах кеша
auto iterSS = SS->Profiles.DefNode.find(id);
if(iterSS != SS->Profiles.DefNode.end()) {
auto iterSS = SS->Profiles.DefNodes.find(id);
if(iterSS != SS->Profiles.DefNodes.end()) {
return (profilesNodeCache[id] = &iterSS->second);
} else {
// Профиль отсутствует на клиенте
@@ -189,18 +189,19 @@ void ChunkMeshGenerator::run(uint8_t id) {
std::unordered_map<DefNodeId, bool> nodeFullCuboidCache;
auto nodeIsFull = [&](Node node) -> bool {
if(node.NodeId == 0)
return false;
auto iterCache = nodeFullCuboidCache.find(node.Data);
if(iterCache == nodeFullCuboidCache.end()) {
const DefNode_t* profile = getNodeProfile(node.NodeId);
if(profile->TexId != 0) {
return (nodeFullCuboidCache[node.Data] = true);
}
if(NSP && profile->NodestateId != 0 && NSP->hasNodestate(profile->NodestateId)) {
const DefNode* profile = getNodeProfile(node.NodeId);
if(NSP) {
if(const AssetsNodestate* ptr = std::get_if<AssetsNodestate>(&profile->RenderStates)) {
if(NSP->hasNodestate(*ptr)) {
std::unordered_map<std::string, int32_t> states;
int32_t meta = node.Meta;
states.emplace("meta", meta);
const auto routes = NSP->getModelsForNode(profile->NodestateId, metaStatesInfo, states);
const auto routes = NSP->getModelsForNode(*ptr, metaStatesInfo, states);
bool isFull = !routes.empty();
if(isFull) {
for(const auto& variants : routes) {
@@ -225,10 +226,13 @@ void ChunkMeshGenerator::run(uint8_t id) {
break;
}
}
return (nodeFullCuboidCache[node.Data] = isFull);
}
}
}
return (nodeFullCuboidCache[node.Data] = false);
return (nodeFullCuboidCache[node.Data] = true);
} else {
return iterCache->second;
}
@@ -420,6 +424,10 @@ void ChunkMeshGenerator::run(uint8_t id) {
for(int z = 0; z < 16; z++)
for(int y = 0; y < 16; y++)
for(int x = 0; x < 16; x++) {
const Node& nodeData = (*chunk)[x+y*16+z*16*16];
if(nodeData.NodeId == 0)
continue;
const size_t vertexStart = result.NodeVertexs.size();
int fullCovered = 0;
@@ -433,28 +441,20 @@ void ChunkMeshGenerator::run(uint8_t id) {
if(fullCovered == 0b111111)
continue;
const Node& nodeData = (*chunk)[x+y*16+z*16*16];
const DefNode_t* node = getNodeProfile(nodeData.NodeId);
if(debugMeshEnabled) {
const bool hasRenderable = (node->NodestateId != 0) || (node->TexId != 0);
if(hasRenderable && fullCovered != 0b111111) {
expectedColumnX[x] = 1;
expectedColumnY[y] = 1;
expectedColumnZ[z] = 1;
}
}
const DefNode* node = getNodeProfile(nodeData.NodeId);
bool usedModel = false;
if(NSP && (node->NodestateId != 0 || NSP->hasNodestate(node->NodestateId))) {
if(NSP) {
if(const AssetsNodestate* ptr = std::get_if<AssetsNodestate>(&node->RenderStates)) {
if(NSP->hasNodestate(*ptr)) {
auto iterCache = modelCache.find(nodeData.Data);
if(iterCache == modelCache.end()) {
std::unordered_map<std::string, int32_t> states;
states.emplace("meta", nodeData.Meta);
ModelCacheEntry entry;
entry.Routes = NSP->getModelsForNode(node->NodestateId, metaStatesInfo, states);
entry.Routes = NSP->getModelsForNode(*ptr, metaStatesInfo, states);
iterCache = modelCache.emplace(nodeData.Data, std::move(entry)).first;
}
@@ -474,25 +474,13 @@ void ChunkMeshGenerator::run(uint8_t id) {
usedModel = true;
}
}
}
}
if(usedModel)
goto node_done;
if(NSP && node->TexId != 0) {
auto iterTex = baseTextureCache.find(node->TexId);
if(iterTex != baseTextureCache.end()) {
v.Tex = iterTex->second;
} else {
uint32_t resolvedTex = NSP->getTextureId(node->TexId);
v.Tex = resolvedTex;
baseTextureCache.emplace(node->TexId, resolvedTex);
}
} else {
v.Tex = node->TexId;
}
if(v.Tex == 0)
goto node_done;
v.Tex = 0;
// Рендерим обычный кубоид
// XZ+Y
@@ -700,58 +688,6 @@ void ChunkMeshGenerator::run(uint8_t id) {
}
node_done:
if(debugMeshEnabled) {
const bool emitted = result.NodeVertexs.size() > vertexStart;
if(emitted) {
generatedColumnX[x] = 1;
generatedColumnY[y] = 1;
generatedColumnZ[z] = 1;
} else {
const bool hasRenderable = (node->NodestateId != 0) || (node->TexId != 0);
if(hasRenderable && fullCovered != 0b111111) {
uint32_t warnIndex = debugMeshWarnCount.fetch_add(1);
if(warnIndex < 16) {
LOG.warn() << "Missing node geometry at chunk " << int(pos[0]) << ','
<< int(pos[1]) << ',' << int(pos[2])
<< " local " << x << ',' << y << ',' << z
<< " nodeId " << nodeData.NodeId
<< " meta " << int(nodeData.Meta)
<< " covered " << fullCovered
<< " tex " << node->TexId
<< " nodestate " << node->NodestateId;
}
}
}
}
}
if(debugMeshEnabled) {
auto collectMissing = [](const std::array<uint8_t, 16>& expected,
const std::array<uint8_t, 16>& generated) {
std::string res;
for(int i = 0; i < 16; i++) {
if(expected[i] && !generated[i]) {
if(!res.empty())
res += ',';
res += std::to_string(i);
}
}
return res;
};
std::string missingX = collectMissing(expectedColumnX, generatedColumnX);
std::string missingY = collectMissing(expectedColumnY, generatedColumnY);
std::string missingZ = collectMissing(expectedColumnZ, generatedColumnZ);
if(!missingX.empty() || !missingY.empty() || !missingZ.empty()) {
uint32_t warnIndex = debugMeshWarnCount.fetch_add(1);
if(warnIndex < 16) {
LOG.warn() << "Missing mesh columns at chunk " << int(pos[0]) << ','
<< int(pos[1]) << ',' << int(pos[2])
<< " missingX[" << missingX << "]"
<< " missingY[" << missingY << "]"
<< " missingZ[" << missingZ << "]";
}
}
}
// Вычислить индексы и сократить вершины
@@ -1700,8 +1636,9 @@ void VulkanRenderSession::tickSync(TickSyncData& data) {
for(AssetsNodestate id : changedNodestates)
changed.insert(id);
for(const auto& [nodeId, def] : ServerSession->Profiles.DefNode) {
if(changed.contains(def.NodestateId))
for(const auto& [nodeId, def] : ServerSession->Profiles.DefNodes) {
if(const AssetsNodestate* ptr = std::get_if<AssetsNodestate>(&def.RenderStates))
if(changed.contains(*ptr))
mcpData.ChangedNodes.push_back(nodeId);
}
}

13
Src/Client/Vulkan/VulkanRenderSession.hpp
View File

@@ -254,9 +254,6 @@ public:
}
{
static std::atomic<uint32_t> debugModelLogCount = 0;
uint32_t idx = debugModelLogCount.fetch_add(1);
if(idx < 128) {
size_t vertexCount = 0;
for(const auto& [_, verts] : model.Vertecies)
vertexCount += verts.size();
@@ -265,16 +262,6 @@ public:
<< " texKeys=" << model.TextureKeys.size()
<< " pipelines=" << header.TexturePipelines.size();
}
}
if(model.Vertecies.empty()) {
static std::atomic<uint32_t> debugEmptyModelLogCount = 0;
uint32_t idx = debugEmptyModelLogCount.fetch_add(1);
if(idx < 128) {
LOG.warn() << "Model has empty geometry id=" << key
<< " pipelines=" << header.TexturePipelines.size();
}
}
Models.insert_or_assign(key, std::move(model));
}

6
Src/Common/IdProvider.hpp
View File

@@ -161,8 +161,7 @@ public:
// reverse читаем под shared lock
std::shared_lock rlk(_ReverseMutex[t]);
for(ResourceId id : new_ids) {
// id=0 не бывает в newlyInserted
const std::size_t idx = static_cast<std::size_t>(id - 1);
const std::size_t idx = static_cast<std::size_t>(id);
if(idx >= _Reverse[t].size()) {
// теоретически не должно случаться (мы пишем reverse до push в log)
continue;
@@ -175,8 +174,7 @@ public:
rlk.unlock();
// 3) дописать в IdToDK (для новых клиентов)
// Важно: IdToDK[0] уже содержит "core/none" как элемент 0.
IdToDK[t].append_range(result[t]); // C++23
IdToDK[t].append_range(result[t]);
}
return result;

1
Src/Common/Packets.hpp
View File

@@ -92,6 +92,7 @@ enum struct ToClient : uint8_t {
AssetsInitSend, // Начало отправки запрошенного клиентом ресурса
AssetsNextSend, // Продолжение отправки ресурса
DefinitionsFull, // Полная информация о профилях контента
DefinitionsUpdate, // Обновление и потеря профилей контента (воксели, ноды, сущности, миры, ...)
ChunkVoxels, // Обновление вокселей чанка

22
Src/Server/AssetsManager.hpp
View File

@@ -46,6 +46,28 @@ public:
Out_applyResourcesUpdate applyResourcesUpdate(Out_checkAndPrepareResourcesUpdate& orr) {
Out_applyResourcesUpdate result = AssetsPreloader::applyResourcesUpdate(orr);
{
static TOS::Logger LOG = "Server>AssetsManager";
for(size_t type = 0; type < static_cast<size_t>(EnumAssets::MAX_ENUM); ++type) {
if(result.NewOrUpdates[type].empty())
continue;
EnumAssets typeEnum = static_cast<EnumAssets>(type);
const char* typeName = ::EnumAssetsToDirectory(typeEnum);
for(const auto& bind : result.NewOrUpdates[type]) {
auto dk = getDK(typeEnum, bind.Id);
if(!dk)
continue;
LOG.debug()
<< typeName << ": "
<< dk->Domain << '+' << dk->Key << " -> " << bind.Id;
}
}
}
for(auto& [hash, data] : orr.NewHeadless) {
Resources.emplace(hash, ResourceHashData{0, std::make_shared<std::u8string>(std::move(data))});
}

213
Src/Server/ContentManager.cpp
View File

@@ -1,6 +1,8 @@
#include "ContentManager.hpp"
#include "Common/Abstract.hpp"
#include <algorithm>
#include <optional>
#include <utility>
namespace LV::Server {
@@ -12,13 +14,22 @@ ContentManager::ContentManager(AssetsManager& am)
ContentManager::~ContentManager() = default;
void ContentManager::registerBase_Node(ResourceId id, const std::string& domain, const std::string& key, const sol::table& profile) {
std::optional<DefNode>& node = getEntry_Node(id);
if(!node)
node.emplace();
std::optional<DefNode_Base>* basePtr;
DefNode& def = *node;
def.Domain = domain;
def.Key = key;
{
size_t entryIndex = id / TableEntry<DefNode_Base>::ChunkSize;
size_t entryId = id % TableEntry<DefNode_Base>::ChunkSize;
size_t need = entryIndex+1-Profiles_Base_Node.size();
for(size_t iter = 0; iter < need; iter++) {
Profiles_Base_Node.emplace_back(std::make_unique<TableEntry<DefNode_Base>>());
}
basePtr = &Profiles_Base_Node[entryIndex]->Entries[entryId];
*basePtr = DefNode_Base();
}
DefNode_Base& def = **basePtr;
{
std::optional<std::variant<std::string, sol::table>> parent = profile.get<std::optional<std::variant<std::string, sol::table>>>("parent");
@@ -92,7 +103,7 @@ void ContentManager::registerBase_Entity(ResourceId id, const std::string& domai
void ContentManager::registerBase(EnumDefContent type, const std::string& domain, const std::string& key, const sol::table& profile)
{
ResourceId id = getId(type, domain, key);
ProfileChanges[(int) type].push_back(id);
ProfileChanges[static_cast<size_t>(type)].push_back(id);
if(type == EnumDefContent::Node)
registerBase_Node(id, domain, key, profile);
@@ -122,11 +133,54 @@ void ContentManager::unRegisterModifier(EnumDefContent type, const std::string&
ProfileChanges[(int) type].push_back(id);
}
void ContentManager::markAllProfilesDirty(EnumDefContent type) {
const auto &table = this->idToDK()[(int) type];
size_t counter = 0;
for(const auto& [domain, key] : table) {
ProfileChanges[static_cast<size_t>(type)].push_back(counter++);
// void ContentManager::markAllProfilesDirty(EnumDefContent type) {
// const auto &table = this->idToDK()[(int) type];
// size_t counter = 0;
// for(const auto& [domain, key] : table) {
// ProfileChanges[static_cast<size_t>(type)].push_back(counter++);
// }
// }
template<class type, class modType>
void ContentManager::buildEndProfilesByType(auto& profiles, auto enumType, auto& base, auto& keys, auto& result, auto& modsTable) {
// Расширяем таблицу итоговых профилей до нужного количества
if(!keys.empty()) {
size_t need = keys.back() / TableEntry<type>::ChunkSize;
if(need >= profiles.size()) {
profiles.reserve(need);
for(size_t iter = 0; iter <= need-profiles.size(); ++iter)
profiles.emplace_back(std::make_unique<TableEntry<type>>());
}
}
TOS::Logger("CM").debug() << "type: " << static_cast<size_t>(enumType);
// Пересчитываем профили
for(size_t id : keys) {
size_t entryIndex = id / TableEntry<type>::ChunkSize;
size_t subIndex = id % TableEntry<type>::ChunkSize;
if(
entryIndex >= base.size()
|| !base[entryIndex]->Entries[subIndex]
) {
// Базовый профиль не существует
profiles[entryIndex]->Entries[subIndex] = std::nullopt;
// Уведомляем о потере профиля
result.LostProfiles[static_cast<size_t>(enumType)].push_back(id);
} else {
// Собираем конечный профиль
std::vector<std::tuple<std::string, modType>> mods_default, *mods = &mods_default;
auto iter = modsTable.find(id);
if(iter != modsTable.end())
mods = &iter->second;
std::optional<BindDomainKeyInfo> dk = getDK(enumType, id);
assert(dk);
TOS::Logger("CM").debug() << "\t" << dk->Domain << ":" << dk->Key << " -> " << id;
profiles[entryIndex]->Entries[subIndex] = base[entryIndex]->Entries[subIndex]->compile(AM, *this, dk->Domain, dk->Key, *mods);
}
}
}
@@ -134,15 +188,148 @@ ContentManager::Out_buildEndProfiles ContentManager::buildEndProfiles() {
Out_buildEndProfiles result;
for(int type = 0; type < (int) EnumDefContent::MAX_ENUM; type++) {
std::shared_lock lock(Profiles_Mtx[type]);
auto& keys = ProfileChanges[type];
std::sort(keys.begin(), keys.end());
auto iterErase = std::unique(keys.begin(), keys.end());
keys.erase(iterErase, keys.end());
switch(type) {
case 0: buildEndProfilesByType<DefVoxel, DefVoxel_Mod> (Profiles_Voxel, EnumDefContent::Voxel, Profiles_Base_Voxel, keys, result, Profiles_Mod_Voxel); break;
case 1: buildEndProfilesByType<DefNode, DefNode_Mod> (Profiles_Node, EnumDefContent::Node, Profiles_Base_Node, keys, result, Profiles_Mod_Node); break;
case 2: buildEndProfilesByType<DefWorld, DefWorld_Mod> (Profiles_World, EnumDefContent::World, Profiles_Base_World, keys, result, Profiles_Mod_World); break;
case 3: buildEndProfilesByType<DefPortal, DefPortal_Mod> (Profiles_Portal, EnumDefContent::Portal, Profiles_Base_Portal, keys, result, Profiles_Mod_Portal); break;
case 4: buildEndProfilesByType<DefEntity, DefEntity_Mod> (Profiles_Entity, EnumDefContent::Entity, Profiles_Base_Entity, keys, result, Profiles_Mod_Entity); break;
case 5: buildEndProfilesByType<DefItem, DefItem_Mod> (Profiles_Item, EnumDefContent::Item, Profiles_Base_Item, keys, result, Profiles_Mod_Item); break;
default: std::unreachable();
}
}
return result;
}
ContentManager::Out_getAllProfiles ContentManager::getAllProfiles() {
Out_getAllProfiles result;
size_t counter;
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Voxel)]);
result.ProfilesIds_Voxel.reserve(Profiles_Voxel.size()*TableEntry<DefVoxel>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_Voxel)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_Voxel.push_back(id);
}
result.ProfilesIds_Voxel.shrink_to_fit();
result.Profiles_Voxel.reserve(result.ProfilesIds_Voxel.size());
for(const auto& entry : Profiles_Voxel)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_Voxel.push_back(&item.value());
}
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Node)]);
result.ProfilesIds_Node.reserve(Profiles_Node.size()*TableEntry<DefNode>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_Node)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_Node.push_back(id);
}
result.ProfilesIds_Node.shrink_to_fit();
result.Profiles_Node.reserve(result.ProfilesIds_Node.size());
for(const auto& entry : Profiles_Node)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_Node.push_back(&item.value());
}
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::World)]);
result.ProfilesIds_World.reserve(Profiles_World.size()*TableEntry<DefWorld>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_World)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_World.push_back(id);
}
result.ProfilesIds_World.shrink_to_fit();
result.Profiles_World.reserve(result.ProfilesIds_World.size());
for(const auto& entry : Profiles_World)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_World.push_back(&item.value());
}
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Portal)]);
result.ProfilesIds_Portal.reserve(Profiles_Portal.size()*TableEntry<DefPortal>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_Portal)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_Portal.push_back(id);
}
result.ProfilesIds_Portal.shrink_to_fit();
result.Profiles_Portal.reserve(result.ProfilesIds_Portal.size());
for(const auto& entry : Profiles_Portal)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_Portal.push_back(&item.value());
}
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Entity)]);
result.ProfilesIds_Entity.reserve(Profiles_Entity.size()*TableEntry<DefEntity>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_Entity)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_Entity.push_back(id);
}
result.ProfilesIds_Entity.shrink_to_fit();
result.Profiles_Entity.reserve(result.ProfilesIds_Entity.size());
for(const auto& entry : Profiles_Entity)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_Entity.push_back(&item.value());
}
{
std::shared_lock lock(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Item)]);
result.ProfilesIds_Item.reserve(Profiles_Item.size()*TableEntry<DefItem>::ChunkSize);
counter = 0;
for(const auto& entry : Profiles_Item)
for(const auto& item : entry->Entries) {
size_t id = counter++;
if(item)
result.ProfilesIds_Item.push_back(id);
}
result.ProfilesIds_Item.shrink_to_fit();
result.Profiles_Item.reserve(result.ProfilesIds_Item.size());
for(const auto& entry : Profiles_Item)
for(const auto& item : entry->Entries)
if(item)
result.Profiles_Item.push_back(&item.value());
}
result.IdToDK = idToDK();
return result;
}
}

194
Src/Server/ContentManager.hpp
View File

@@ -3,20 +3,62 @@
#include "Common/Abstract.hpp"
#include "AssetsManager.hpp"
#include "Common/IdProvider.hpp"
#include "Common/Net.hpp"
#include "TOSLib.hpp"
#include <array>
#include <mutex>
#include <sol/table.hpp>
#include <string_view>
#include <unordered_map>
namespace LV::Server {
struct DefVoxel_Base { };
struct DefNode_Base { };
struct DefWorld_Base { };
struct DefPortal_Base { };
struct DefEntity_Base { };
struct DefItem_Base { };
struct ResourceBase {
std::string Domain, Key;
};
class ContentManager;
struct DefVoxel : public ResourceBase {
std::u8string dumpToClient() const {
return {};
}
};
struct DefNode : public ResourceBase {
AssetsNodestate NodestateId;
std::u8string dumpToClient() const {
auto wr = TOS::ByteBuffer::Writer();
wr << uint32_t(NodestateId);
auto buff = wr.complite();
return (std::u8string) std::u8string_view((const char8_t*) buff.data(), buff.size());
}
};
struct DefWorld : public ResourceBase {
std::u8string dumpToClient() const {
return {};
}
};
struct DefPortal : public ResourceBase {
std::u8string dumpToClient() const {
return {};
}
};
struct DefEntity : public ResourceBase {
std::u8string dumpToClient() const {
return {};
}
};
struct DefItem : public ResourceBase {
std::u8string dumpToClient() const {
return {};
}
};
struct DefVoxel_Mod { };
struct DefNode_Mod { };
@@ -25,20 +67,57 @@ struct DefPortal_Mod { };
struct DefEntity_Mod { };
struct DefItem_Mod { };
struct ResourceBase {
std::string Domain, Key;
struct DefVoxel_Base {
private:
friend ContentManager;
DefVoxel compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefVoxel_Mod>>& mods) const {
return DefVoxel();
}
};
struct DefVoxel : public ResourceBase { };
struct DefNode : public ResourceBase {
AssetsNodestate NodestateId;
std::vector<AssetsModel> ModelDeps;
std::vector<AssetsTexture> TextureDeps;
struct DefNode_Base {
private:
friend ContentManager;
DefNode compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefNode_Mod>>& mods) const {
DefNode profile;
std::string jsonKey = std::string(key)+".json";
profile.NodestateId = am.getId(EnumAssets::Nodestate, domain, jsonKey);
TOS::Logger("Compile").info() << domain << ' ' << key << " -> " << profile.NodestateId;
return profile;
}
};
struct DefWorld_Base {
private:
friend ContentManager;
DefWorld compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefWorld_Mod>>& mods) const {
return DefWorld();
}
};
struct DefPortal_Base {
private:
friend ContentManager;
DefPortal compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefPortal_Mod>>& mods) const {
return DefPortal();
}
};
struct DefEntity_Base {
private:
friend ContentManager;
DefEntity compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefEntity_Mod>>& mods) const {
return DefEntity();
}
};
struct DefItem_Base {
private:
friend ContentManager;
DefItem compile(AssetsManager& am, ContentManager& cm, const std::string_view domain, const std::string_view key, const std::vector<std::tuple<std::string, DefItem_Mod>>& mods) const {
return DefItem();
}
};
struct DefWorld : public ResourceBase { };
struct DefPortal : public ResourceBase { };
struct DefEntity : public ResourceBase { };
struct DefItem : public ResourceBase { };
/*
DK to id
@@ -114,7 +193,7 @@ public:
MAX_ENUM
> DKToId;
std::unordered_map<DefVoxelId, std::optional<DefItem>*> Profiles_Voxel;
std::unordered_map<DefVoxelId, std::optional<DefVoxel>*> Profiles_Voxel;
std::unordered_map<DefNodeId, std::optional<DefNode>*> Profiles_Node;
std::unordered_map<DefWorldId, std::optional<DefWorld>*> Profiles_World;
std::unordered_map<DefPortalId, std::optional<DefPortal>*> Profiles_Portal;
@@ -133,16 +212,77 @@ public:
void registerModifier(EnumDefContent type, const std::string& mod, const std::string& domain, const std::string& key, const sol::table& profile);
void unRegisterModifier(EnumDefContent type, const std::string& mod, const std::string& domain, const std::string& key);
// Пометить все профили типа как изменённые (например, после перезагрузки ассетов)
void markAllProfilesDirty(EnumDefContent type);
// void markAllProfilesDirty(EnumDefContent type);
// Список всех зарегистрированных профилей выбранного типа
std::vector<ResourceId> collectProfileIds(EnumDefContent type) const;
// Компилирует изменённые профили
struct Out_buildEndProfiles {
std::vector<ResourceId> ChangedProfiles[MAX_ENUM];
std::vector<
std::tuple<DefVoxelId, const DefVoxel*>
> ChangedProfiles_Voxel;
std::vector<
std::tuple<DefNodeId, const DefNode*>
> ChangedProfiles_Node;
std::vector<
std::tuple<DefWorldId, const DefWorld*>
> ChangedProfiles_World;
std::vector<
std::tuple<DefPortalId, const DefPortal*>
> ChangedProfiles_Portal;
std::vector<
std::tuple<DefEntityId, const DefEntity*>
> ChangedProfiles_Entity;
std::vector<
std::tuple<DefItemId, const DefItem*>
> ChangedProfiles_Item;
std::array<
std::vector<ResourceId>,
MAX_ENUM
> LostProfiles;
std::array<
std::vector<BindDomainKeyInfo>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> IdToDK;
};
// Компилирует конечные профили по базе и модификаторам (предоставляет клиентам изменённые и потерянные)
Out_buildEndProfiles buildEndProfiles();
struct Out_getAllProfiles {
std::vector<DefVoxelId> ProfilesIds_Voxel;
std::vector<const DefVoxel*> Profiles_Voxel;
std::vector<DefNodeId> ProfilesIds_Node;
std::vector<const DefNode*> Profiles_Node;
std::vector<DefWorldId> ProfilesIds_World;
std::vector<const DefWorld*> Profiles_World;
std::vector<DefPortalId> ProfilesIds_Portal;
std::vector<const DefPortal*> Profiles_Portal;
std::vector<DefEntityId> ProfilesIds_Entity;
std::vector<const DefEntity*> Profiles_Entity;
std::vector<DefItemId> ProfilesIds_Item;
std::vector<const DefItem*> Profiles_Item;
std::array<
std::vector<BindDomainKeyInfo>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> IdToDK;
};
// Выдаёт все профили (для новых клиентов)
Out_getAllProfiles getAllProfiles();
std::optional<DefVoxel>& getEntry_Voxel(ResourceId resId) {
std::shared_lock mtx(Profiles_Mtx[static_cast<size_t>(EnumDefContent::Voxel)]);
@@ -278,17 +418,19 @@ private:
void registerBase_World(ResourceId id, const std::string& domain, const std::string& key, const sol::table& profile);
void registerBase_Entity(ResourceId id, const std::string& domain, const std::string& key, const sol::table& profile);
template<class type, class modType>
void buildEndProfilesByType(auto& profiles, auto enumType, auto& base, auto& keys, auto& result, auto& mods);
TOS::Logger LOG = "Server>ContentManager";
AssetsManager& AM;
// Профили зарегистрированные модами
std::vector<std::unique_ptr<TableEntry<DefVoxel>>> Profiles_Base_Voxel;
std::vector<std::unique_ptr<TableEntry<DefNode>>> Profiles_Base_Node;
std::vector<std::unique_ptr<TableEntry<DefWorld>>> Profiles_Base_World;
std::vector<std::unique_ptr<TableEntry<DefPortal>>> Profiles_Base_Portal;
std::vector<std::unique_ptr<TableEntry<DefEntity>>> Profiles_Base_Entity;
std::vector<std::unique_ptr<TableEntry<DefItem>>> Profiles_Base_Item;
std::vector<std::unique_ptr<TableEntry<DefVoxel_Base>>> Profiles_Base_Voxel;
std::vector<std::unique_ptr<TableEntry<DefNode_Base>>> Profiles_Base_Node;
std::vector<std::unique_ptr<TableEntry<DefWorld_Base>>> Profiles_Base_World;
std::vector<std::unique_ptr<TableEntry<DefPortal_Base>>> Profiles_Base_Portal;
std::vector<std::unique_ptr<TableEntry<DefEntity_Base>>> Profiles_Base_Entity;
std::vector<std::unique_ptr<TableEntry<DefItem_Base>>> Profiles_Base_Item;
// Изменения, накладываемые на профили
// Идентификатор [домен мода модификатора, модификатор]

7
Src/Server/GameServer.cpp
View File

@@ -786,7 +786,7 @@ void GameServer::BackingAsyncLua_t::run(int id) {
uint8_t kMetaGrass = 1;
DefNodeId kNodeDirt = lru.getIdNode("test", "dirt");
DefNodeId kNodeStone = lru.getIdNode("test", "stone");
DefNodeId kNodeWood = lru.getIdNode("test", "wood");
DefNodeId kNodeWood = lru.getIdNode("test", "log");
DefNodeId kNodeLeaves = lru.getIdNode("test", "leaves");
DefNodeId kNodeLava = lru.getIdNode("test", "lava");
DefNodeId kNodeWater = lru.getIdNode("test", "water");
@@ -1370,7 +1370,6 @@ void GameServer::init(fs::path worldPath) {
Content.CM.buildEndProfiles();
LOG.info() << "Инициализация";
initLua();
pushEvent("init");
@@ -1615,6 +1614,7 @@ void GameServer::stepConnections() {
std::vector<Net::Packet> packets;
packets.push_back(RemoteClient::makePacket_informateAssets_DK(Content.AM.idToDK()));
packets.push_back(RemoteClient::makePacket_informateAssets_HH(Content.AM.collectHashBindings(), lost));
packets.append_range(RemoteClient::makePackets_informateDefContent_Full(Content.CM.getAllProfiles()));
for(const std::shared_ptr<RemoteClient>& client : newClients) {
if(!packets.empty()) {
@@ -1685,7 +1685,8 @@ void GameServer::reloadMods() {
{
// TODO: перезагрузка модов
Content.CM.buildEndProfiles();
ContentManager::Out_buildEndProfiles out = Content.CM.buildEndProfiles();
packetsToSend.append_range(RemoteClient::makePackets_informateDefContentUpdate(out));
}
LOG.info() << "Перезагрузка ассетов";

211
Src/Server/RemoteClient.cpp
View File

@@ -94,24 +94,122 @@ Net::Packet RemoteClient::makePacket_informateAssets_HH(
return pack;
}
std::vector<Net::Packet> RemoteClient::makePackets_sendDefContentUpdate(
std::array<
std::vector<
std::pair<
ResourceId, // Идентификатор профиля
std::u8string // Двоичный формат профиля
>
>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> newOrUpdate, // Новые или изменённые
std::array<
std::vector<ResourceId>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> lost, // Потерянные профили
std::array<
std::vector<std::pair<std::string, std::string>>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> idToDK // Новые привязки
std::vector<Net::Packet> RemoteClient::makePackets_informateDefContent_Full(
const ContentManager::Out_getAllProfiles& profiles
) {
std::vector<Net::Packet> packets;
Net::Packet pack;
auto check = [&](size_t needSize) {
if(pack.size()+needSize > 65500) {
packets.emplace_back(std::move(pack));
pack.clear();
}
};
pack << (uint8_t) ToClient::DefinitionsFull;
{
pack << (uint32_t) profiles.ProfilesIds_Voxel.size();
for(uint32_t id : profiles.ProfilesIds_Voxel) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_Voxel) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << (uint32_t) profiles.ProfilesIds_Node.size();
for(uint32_t id : profiles.ProfilesIds_Node) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_Node) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << (uint32_t) profiles.ProfilesIds_World.size();
for(uint32_t id : profiles.ProfilesIds_World) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_World) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << (uint32_t) profiles.ProfilesIds_Portal.size();
for(uint32_t id : profiles.ProfilesIds_Portal) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_Portal) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << (uint32_t) profiles.ProfilesIds_Entity.size();
for(uint32_t id : profiles.ProfilesIds_Entity) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_Entity) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << (uint32_t) profiles.ProfilesIds_Item.size();
for(uint32_t id : profiles.ProfilesIds_Item) {
check(4);
pack << id;
}
for(const auto& profile : profiles.Profiles_Item) {
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
pack << uint32_t(profiles.IdToDK[type].size());
for(const auto& [domain, key] : profiles.IdToDK[type]) {
check(domain.size() + key.size() + 8);
pack << domain << key;
}
}
if(pack.size())
packets.emplace_back(std::move(pack));
return packets;
}
std::vector<Net::Packet> RemoteClient::makePackets_informateDefContentUpdate(
const ContentManager::Out_buildEndProfiles& profiles
) {
std::vector<Net::Packet> packets;
Net::Packet pack;
@@ -124,35 +222,88 @@ std::vector<Net::Packet> RemoteClient::makePackets_sendDefContentUpdate(
};
pack << (uint8_t) ToClient::DefinitionsUpdate;
pack << uint32_t(newOrUpdate.size());
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
pack << uint32_t(newOrUpdate[type].size());
for(const auto& [id, data] : newOrUpdate[type]) {
{
pack << uint32_t(profiles.ChangedProfiles_Voxel.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_Voxel) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << id << (const std::string&) data;
pack << std::string_view((const char*) data.data(), data.size());
}
}
pack << uint32_t(lost.size());
{
pack << uint32_t(profiles.ChangedProfiles_Node.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_Node) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << uint32_t(profiles.ChangedProfiles_World.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_World) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << uint32_t(profiles.ChangedProfiles_Portal.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_Portal) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << uint32_t(profiles.ChangedProfiles_Entity.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_Entity) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
pack << uint32_t(profiles.ChangedProfiles_Item.size());
for(const auto& [id, profile] : profiles.ChangedProfiles_Item) {
pack << id;
std::u8string data = profile->dumpToClient();
check(data.size());
pack << std::string_view((const char*) data.data(), data.size());
}
}
{
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
pack << uint32_t(lost[type].size());
pack << uint32_t(profiles.LostProfiles[type].size());
for(ResourceId id : lost[type]) {
check(4);
for(const ResourceId id : profiles.LostProfiles[type]) {
check(sizeof(ResourceId));
pack << id;
}
}
}
pack << uint32_t(idToDK.size());
{
for(size_t type = 0; type < static_cast<size_t>(EnumDefContent::MAX_ENUM); type++) {
pack << uint32_t(idToDK[type].size());
pack << uint32_t(profiles.IdToDK[type].size());
for(const auto& [domain, key] : idToDK[type]) {
for(const auto& [domain, key] : profiles.IdToDK[type]) {
check(domain.size() + key.size() + 8);
pack << key << domain;
}
}
}
if(pack.size())
packets.emplace_back(std::move(pack));

26
Src/Server/RemoteClient.hpp
View File

@@ -388,25 +388,15 @@ public:
const std::vector<std::tuple<ResourceFile::Hash_t, std::shared_ptr<const std::u8string>>>& resources
);
// Создаёт пакет со всеми данными об игровых профилях
static std::vector<Net::Packet> makePackets_informateDefContent_Full(
const ContentManager::Out_getAllProfiles& profiles
);
// Создаёт пакет об обновлении игровых профилей
static std::vector<Net::Packet> makePackets_sendDefContentUpdate(
std::array<
std::vector<
std::pair<
ResourceId, // Идентификатор профиля
std::u8string // Двоичный формат профиля
>
>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> newOrUpdate, // Новые или изменённые
std::array<
std::vector<ResourceId>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> lost, // Потерянные профили
std::array<
std::vector<std::pair<std::string, std::string>>,
static_cast<size_t>(EnumDefContent::MAX_ENUM)
> idToDK // Новые привязки
static std::vector<Net::Packet> makePackets_informateDefContentUpdate(
const ContentManager::Out_buildEndProfiles& profiles
);
void onUpdate();