work

network/manager.cpp

@@ -7,7 +7,7 @@ network::manager::manager()
 
 void network::manager::create_server()
 {
-	servers.emplace_back(std::make_shared<tcp_server>(io_context));
+	server = std::make_shared<tcp_server>(io_context);
 }
 
 void network::manager::poll()
@@ -19,3 +19,13 @@ void network::manager::connect()
 {
 	client = std::make_shared<tcp_client>(io_context);
 }
+
+std::tuple<double, command_queue::commanddatasequence_map> network::manager::get_next_delta()
+{
+	return client->get_next_delta();
+}
+
+void network::manager::push_delta(double delta, command_queue::commanddatasequence_map commands)
+{
+	server->push_delta(delta, commands);
+}

network/manager.h

@@ -2,13 +2,14 @@
 #include <asio.hpp>
 #include <memory>
 #include "network/network.h"
+#include "command.h"
 
 namespace network
 {
     class manager
 	{
 		asio::io_context io_context;
-		std::vector<std::shared_ptr<server>> servers;
+		std::shared_ptr<network::server> server;
 		std::shared_ptr<network::client> client;
 
 	public:
@@ -17,5 +18,8 @@ namespace network
 		void create_server();
 		void connect();
 		void poll();
+
+		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
+		void push_delta(double delta, command_queue::commanddatasequence_map commands);
 	};
 }

network/message.cpp

@@ -3,16 +3,85 @@
 
 void network::message::serialize(std::ostream &stream)
 {
-	sn_utils::ls_uint16(stream, (uint16_t)type);
+
 }
 
-network::message network::message::deserialize(std::istream &stream)
+void network::message::deserialize(std::istream &stream)
 {
-	type_e type = (type_e)sn_utils::ld_uint16(stream);
-	if ((int)type > (int)message::TYPE_MAX)
-	{
-		type = message::TYPE_MAX;
+
+}
+
+void::network::delta_message::serialize(std::ostream &stream)
+{
+	sn_utils::ls_float64(stream, dt);
+
+	sn_utils::ls_uint32(stream, commands.size());
+	for (auto const &kv : commands) {
+		sn_utils::ls_uint32(stream, kv.first);
+		sn_utils::ls_uint32(stream, kv.second.size());
+		for (command_data const &data : kv.second) {
+			sn_utils::ls_uint32(stream, (uint32_t)data.command);
+			sn_utils::ls_int32(stream, data.action);
+			sn_utils::ls_float64(stream, data.param1);
+			sn_utils::ls_float64(stream, data.param2);
+			sn_utils::ls_float64(stream, data.time_delta);
+		}
+	}
+}
+
+void network::delta_message::deserialize(std::istream &stream)
+{
+	dt = sn_utils::ld_float64(stream);
+
+	uint32_t commands_size = sn_utils::ld_uint32(stream);
+	for (uint32_t i = 0; i < commands_size; i++) {
+		uint32_t recipient = sn_utils::ld_uint32(stream);
+		uint32_t sequence_size = sn_utils::ld_uint32(stream);
+
+		command_queue::commanddata_sequence sequence;
+		for (uint32_t i = 0; i < sequence_size; i++) {
+			command_data data;
+			data.command = (user_command)sn_utils::ld_uint32(stream);
+			data.action = sn_utils::ld_int32(stream);
+			data.param1 = sn_utils::ld_float64(stream);
+			data.param2 = sn_utils::ld_float64(stream);
+			data.time_delta = sn_utils::ld_float64(stream);
+
+			sequence.emplace_back(data);
+		}
+
+		commands.emplace(recipient, sequence);
+	}
+}
+
+size_t network::delta_message::get_size()
+{
+	size_t cmd_size = 4;
+
+	for (auto const &kv : commands) {
+		cmd_size += 8;
+		for (command_data const &data : kv.second) {
+			cmd_size += 8 + 3 * 8;
+		}
 	}
 
-	return message({type});
+	return message::get_size() + cmd_size + 8;
+}
+
+std::shared_ptr<network::message> network::deserialize_message(std::istream &stream)
+{
+	message::type_e type = (message::type_e)sn_utils::ld_uint16(stream);
+
+	std::shared_ptr<message> msg;
+	if (type == message::STEP_INFO) {
+		auto m = std::make_shared<delta_message>();
+		m->type = type;
+		m->deserialize(stream);
+		msg = m;
+	}
+	else {
+		msg = std::make_shared<message>(type);
+	}
+
+	return msg;
 }

network/message.h

@@ -1,5 +1,7 @@
 #pragma once
 #include "network/message.h"
+#include "command.h"
+#include <queue>
 
 namespace network
 {
@@ -16,8 +18,23 @@ namespace network
 
 		type_e type;
 
-		void serialize(std::ostream &stream);
-
-		static message deserialize(std::istream &stream);
+		message(type_e t) : type(t) {}
+		virtual void serialize(std::ostream &stream);
+		virtual void deserialize(std::istream &stream);
+		virtual size_t get_size() { return 2; }
 	};
+
+	struct delta_message : public message
+	{
+		delta_message() : message(STEP_INFO) {}
+
+		double dt;
+		command_queue::commanddatasequence_map commands;
+
+		virtual void serialize(std::ostream &stream) override;
+		virtual void deserialize(std::istream &stream) override;
+		virtual size_t get_size() override;
+	};
+
+	std::shared_ptr<message> deserialize_message(std::istream &stream);
 }

network/network.cpp

@@ -2,52 +2,102 @@
 #include "network/message.h"
 #include "Logs.h"
 #include "sn_utils.h"
+#include "Timer.h"
 
 void network::connection::connected()
 {
 	WriteLog("net: socket connected", logtype::net);
 
-	message hello;
-	hello.type = message::CONNECT_REQUEST;
+	std::shared_ptr<message> hello = std::make_shared<message>(message::CONNECT_REQUEST);
 	send_message(hello);
 }
 
-void network::connection::message_received(message &msg)
+void network::connection::message_received(std::shared_ptr<message> &msg)
 {
-	if (msg.type == message::TYPE_MAX)
+	if (msg->type == message::TYPE_MAX)
 	{
 		disconnect();
 		return;
 	}
 
-	if (msg.type == message::CONNECT_REQUEST)
+	if (msg->type == message::CONNECT_REQUEST)
 	{
-		message reply({message::CONNECT_ACCEPT});
+		std::shared_ptr<message> reply = std::make_shared<message>(message::CONNECT_ACCEPT);
 
 		WriteLog("client accepted", logtype::net);
 
-		std::string reply_buf;
-		std::ostringstream stream(reply_buf);
-		reply.serialize(stream);
+		send_message(reply);
 	}
+	else if (msg->type == message::CONNECT_ACCEPT)
+	{
+		WriteLog("accept received", logtype::net);
+	}
+	else if (msg->type == message::STEP_INFO)
+	{
+		auto delta = std::dynamic_pointer_cast<delta_message>(msg);
+		auto now = std::chrono::high_resolution_clock::now();
+		delta_queue.push(std::make_pair(now, delta));
+	}
+}
+
+std::tuple<double, command_queue::commanddatasequence_map> network::connection::get_next_delta()
+{
+	if (delta_queue.empty()) {
+		return std::tuple<double,
+		        command_queue::commanddatasequence_map>(0.0, command_queue::commanddatasequence_map());
+	}
+
+	///auto now = std::chrono::high_resolution_clock::now();
+
+	//double last_frame = std::chrono::duration_cast<std::chrono::seconds>(now - last_time).count();
+	//last_time = now;
+	//accum += last_frame;
+
+	auto entry = delta_queue.front();
+
+	//if (accum > remote_dt) {
+	    //accum -= remote_dt;
+
+	    delta_queue.pop();
+		return std::make_tuple(entry.second->dt, entry.second->commands);
+	//}
+	//else {
+		//return 0.0;
+	//}
 }
 
 void network::connection::data_received(std::string &buffer)
 {
 	std::istringstream body(buffer);
-	message msg = message::deserialize(body);
+	std::shared_ptr<message> msg = deserialize_message(body);
 
 	message_received(msg);
 }
 
-void network::connection::send_message(message &msg)
+void network::connection::send_message(std::shared_ptr<message> msg)
 {
 	std::ostringstream stream;
 	sn_utils::ls_uint32(stream, 0x37305545);
-	sn_utils::ls_uint32(stream, 2);
-	msg.serialize(stream);
+	sn_utils::ls_uint32(stream, msg->get_size());
+	sn_utils::ls_uint16(stream, (uint16_t)msg->type);
+	msg->serialize(stream);
 	stream.flush();
 
 	std::shared_ptr<std::string> buf = std::make_shared<std::string>(stream.str());
 	send_data(buf);
 }
+
+void network::server::push_delta(double dt, command_queue::commanddatasequence_map commands)
+{
+	std::shared_ptr<delta_message> msg = std::make_shared<delta_message>();
+	msg->dt = dt;
+	msg->commands = commands;
+
+	for (auto c : clients)
+		c->send_message(msg);
+}
+
+std::tuple<double, command_queue::commanddatasequence_map> network::client::get_next_delta()
+{
+	return conn->get_next_delta();
+}

network/network.h

@@ -3,15 +3,23 @@
 #include <memory>
 #include <functional>
 #include <optional>
+#include <queue>
+#include <chrono>
 #include "network/message.h"
+#include "command.h"
 
 namespace network
 {
     class connection : public std::enable_shared_from_this<connection>
 	{
 	private:
-		void message_received(message &msg);
-		void send_message(message &msg);
+		void message_received(std::shared_ptr<message> &msg);
+		std::queue<
+		    std::pair<std::chrono::high_resolution_clock::time_point,
+		    std::shared_ptr<delta_message>>> delta_queue;
+
+		//std::chrono::high_resolution_clock::time_point last_time;
+		//double accum = -1.0;
 
 	protected:
 		virtual void disconnect() = 0;
@@ -20,16 +28,27 @@ namespace network
 		void data_received(std::string &buffer);
 
 	public:
+		void send_message(std::shared_ptr<message> msg);
 		virtual void connected();
+
+		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
 	};
 
 	class server
 	{
 	protected:
 		std::vector<std::shared_ptr<connection>> clients;
+
+	public:
+		void push_delta(double dt, command_queue::commanddatasequence_map commands);
 	};
 
 	class client
 	{
+	protected:
+		std::shared_ptr<connection> conn;
+
+	public:
+		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
 	};
 }

network/tcp.cpp

@@ -117,10 +117,11 @@ void network::tcp_server::handle_accept(std::shared_ptr<tcp_conn> conn, const as
 network::tcp_client::tcp_client(asio::io_context &io_ctx)
 {
 	conn = std::make_shared<tcp_conn>(io_ctx);
+	auto tcpconn = std::static_pointer_cast<tcp_conn>(conn);
 
 	asio::ip::tcp::endpoint endpoint(
 	            asio::ip::address::from_string("127.0.0.1"), 7424);
-	conn->socket().async_connect(endpoint,
+	tcpconn->socket().async_connect(endpoint,
 	                    std::bind(&tcp_client::handle_accept, this, std::placeholders::_1));
 }
 

network/tcp.h

@@ -47,7 +47,6 @@ namespace network
 	class tcp_client : public client
 	{
 	private:
-		std::shared_ptr<tcp_conn> conn;
 		void handle_accept(const asio::error_code &err);
 
 	public: