copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Added multi command block

Browse source
This commit is contained in:
Yousef Khadadeh 2026-06-02 21:57:53 +03:00
parent 6889eeff60
commit 279a9317a4
14 changed files with 173 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

32
include/Helpers/NetworkingObjects/NetObjManager.cpp
View file

@ -35,24 +35,13 @@ namespace NetworkingObjects {
return;
typeList.get_net_type_data(isServer, it->second.netTypeID).readUpdateFunc(NetObjTemporaryPtr<void>(this, id, it->second.p), a, clientReceivedFrom);
}
void NetObjManager::read_many_update_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom) {
for(;;) {
bool objExists;
a(objExists);
if(!objExists)
break;
read_update_message(a, clientReceivedFrom);
}
}
void NetObjManager::set_client(std::shared_ptr<NetClient> initClient, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID) {
void NetObjManager::set_client(std::shared_ptr<NetClient> initClient, MessageCommandType initUpdateCommandID) {
client = initClient;
updateCommandID = initUpdateCommandID;
multiUpdateCommandID = initMultiUpdateCommandID;
}
void NetObjManager::set_server(std::shared_ptr<NetServer> initServer, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID) {
void NetObjManager::set_server(std::shared_ptr<NetServer> initServer, MessageCommandType initUpdateCommandID) {
server = initServer;
updateCommandID = initUpdateCommandID;
multiUpdateCommandID = initMultiUpdateCommandID;
}
void NetObjManager::disconnect() {
server = nullptr;
@ -67,23 +56,6 @@ namespace NetworkingObjects {
void NetObjManager::set_netobj_destroy_callback(const std::function<void(const NetworkingObjects::NetObjID& netID)>& newDestroyCallback) {
destroyCallback = newDestroyCallback;
}
void NetObjManager::send_multi_update_messsage(std::function<void()> captureSendBlock, SendUpdateType updateType, const std::shared_ptr<NetServer::ClientData>& specificClient) {
if(is_connected() && multiUpdateData.expired()) { // Check for multiUpdateData.expired() to make sure we aren't overriding a previous call to send_multi_update_messsage
std::shared_ptr<MultiUpdateData> d = std::make_shared<MultiUpdateData>();
d->ss = std::make_shared<std::stringstream>(std::ios::binary | std::ios::out);
d->outArchive = std::make_unique<cereal::PortableBinaryOutputArchive>(*d->ss);
(*d->outArchive)(multiUpdateCommandID);
multiUpdateData = d; // Using weak pointer here ensures that object will be freed
captureSendBlock();
if(!d->channelToSendTo.empty()) {
(*d->outArchive)(false);
d->outArchive = nullptr; // Destroy output archive to finalize serialization
send_update_data_by_type(d->channelToSendTo, d->ss, updateType, specificClient);
}
}
else
captureSendBlock();
}
void NetObjManager::send_update_data_by_type(const std::string& channel, const std::shared_ptr<std::stringstream>& ss, SendUpdateType updateType, const std::shared_ptr<NetServer::ClientData>& specificClient) {
if(client && updateType != SendUpdateType::SEND_TO_ALL)

44
include/Helpers/NetworkingObjects/NetObjManager.hpp
View file

@ -40,8 +40,8 @@ namespace NetworkingObjects {
NetObjManager(bool initIsServer);
void read_update_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom);
void read_many_update_message(cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& clientReceivedFrom);
void set_client(std::shared_ptr<NetClient> initClient, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID);
void set_server(std::shared_ptr<NetServer> initServer, MessageCommandType initUpdateCommandID, MessageCommandType initMultiUpdateCommandID);
void set_client(std::shared_ptr<NetClient> initClient, MessageCommandType initUpdateCommandID);
void set_server(std::shared_ptr<NetServer> initServer, MessageCommandType initUpdateCommandID);
void disconnect();
bool is_server() const;
bool is_connected() const;
@ -71,7 +71,6 @@ namespace NetworkingObjects {
SEND_TO_ALL_EXCEPT,
SEND_TO_SPECIFIC_CLIENT
};
void send_multi_update_messsage(std::function<void()> captureSendBlock, SendUpdateType updateType, const std::shared_ptr<NetServer::ClientData>& specificClient);
// NOTE: DO NOT USE THESE FUNCTIONS UNLESS SITUATION ISN'T NORMAL, EVERY OBJECT SHOULD HAVE A UNIQUE ID AND IDS SHOULDNT BE REUSED UNDER ANY CIRCUMSTANCES
template <typename T> NetObjOwnerPtr<T> make_obj_with_specific_id(const NetObjID& id) {
@ -117,49 +116,40 @@ namespace NetworkingObjects {
}
template <typename T> static void send_client_update(const NetObjTemporaryPtr<T>& ptr, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
auto ss = send_update_general(channel, ptr, sendUpdateFunc);
if(ss)
ptr.get_obj_man()->client->send_string_stream_to_server(channel, ss);
}
template <typename T> static void send_server_update_to_client(const NetObjTemporaryPtr<T>& ptr, const std::shared_ptr<NetServer::ClientData>& clientToSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
if(clientToSendTo) {
auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
auto ss = send_update_general(channel, ptr, sendUpdateFunc);
if(ss)
ptr.get_obj_man()->server->send_string_stream_to_client(clientToSendTo, channel, ss);
}
}
template <typename T> static void send_server_update_to_all_clients_except(const NetObjTemporaryPtr<T>& ptr, const std::shared_ptr<NetServer::ClientData>& clientToNotSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
auto ss = send_update_general(channel, ptr, sendUpdateFunc);
if(ss)
ptr.get_obj_man()->server->send_string_stream_to_all_clients_except(clientToNotSendTo, channel, ss);
}
template <typename T> static void send_server_update_to_all_clients(const NetObjTemporaryPtr<T>& ptr, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
auto ss = send_update_general_check_for_multi_update(channel, ptr, sendUpdateFunc);
auto ss = send_update_general(channel, ptr, sendUpdateFunc);
if(ss)
ptr.get_obj_man()->server->send_string_stream_to_all_clients(channel, ss);
}
template <typename T> static std::shared_ptr<std::stringstream> send_update_general_check_for_multi_update(const std::string& channel, const NetObjTemporaryPtr<T>& ptr, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
template <typename T> static std::shared_ptr<std::stringstream> send_update_general(const std::string& channel, const NetObjTemporaryPtr<T>& ptr, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) {
if(ptr.get_obj_man()->is_connected()) {
std::shared_ptr<MultiUpdateData> mData = ptr.get_obj_man()->multiUpdateData.lock();
if(mData) {
mData->channelToSendTo = channel;
(*mData->outArchive)(true, ptr.get_net_id());
sendUpdateFunc(ptr, *mData->outArchive);
return nullptr;
}
else {
auto ss(std::make_shared<std::stringstream>(std::ios::binary | std::ios::out));
{
cereal::PortableBinaryOutputArchive m(*ss);
m(ptr.get_obj_man()->updateCommandID, ptr.get_net_id());
sendUpdateFunc(ptr, m);
}
return ss;
auto ss(std::make_shared<std::stringstream>(std::ios::binary | std::ios::out));
{
cereal::PortableBinaryOutputArchive m(*ss);
m(ptr.get_obj_man()->updateCommandID, ptr.get_net_id());
sendUpdateFunc(ptr, m);
}
return ss;
}
return nullptr;
}
@ -178,18 +168,10 @@ namespace NetworkingObjects {
void* p;
};
struct MultiUpdateData {
std::string channelToSendTo;
std::shared_ptr<std::stringstream> ss;
std::unique_ptr<cereal::PortableBinaryOutputArchive> outArchive;
};
std::weak_ptr<MultiUpdateData> multiUpdateData;
bool isServer;
std::shared_ptr<NetClient> client;
std::shared_ptr<NetServer> server;
MessageCommandType updateCommandID;
MessageCommandType multiUpdateCommandID;
std::unordered_map<NetObjID, SingleObjectData> objectData;
NetObjManagerTypeList typeList;
NetTypeIDType nextTypeID;