work

network/manager.cpp

@@ -1,5 +1,6 @@
 #include "network/manager.h"
 #include "network/tcp.h"
+#include "simulation.h"
 
 network::manager::manager()
 {
@@ -20,12 +21,48 @@ void network::manager::connect()
 	client = std::make_shared<tcp_client>(io_context);
 }
 
-std::tuple<double, command_queue::commanddatasequence_map> network::manager::get_next_delta()
+std::tuple<double, command_queue::commands_map> network::manager::get_next_delta()
 {
 	return client->get_next_delta();
 }
 
-void network::manager::push_delta(double delta, command_queue::commanddatasequence_map commands)
+void network::manager::push_delta(double delta, command_queue::commands_map commands)
 {
 	server->push_delta(delta, commands);
 }
+
+command_queue::commands_map network::manager::pop_commands()
+{
+	return server->pop_commands();
+}
+
+void network::manager::send_commands(command_queue::commands_map commands)
+{
+	client->send_commands(commands);
+}
+
+void network::manager::request_train(std::string name)
+{
+	if (server) {
+		TTrain *train = simulation::Trains.find(name);
+		if (train)
+			return;
+
+		TDynamicObject *dynobj = simulation::Vehicles.find(name);
+		if (!dynobj)
+			return;
+
+		train = new TTrain();
+		if (train->Init(dynobj)) {
+			simulation::Trains.insert(train, name);
+			server->notify_train(name);
+		}
+		else {
+			delete train;
+			train = nullptr;
+		}
+	}
+	if (client) {
+		client->request_train(name);
+	}
+}

network/manager.h

@@ -19,7 +19,10 @@ namespace network
 		void connect();
 		void poll();
 
-		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
-		void push_delta(double delta, command_queue::commanddatasequence_map commands);
+		std::tuple<double, command_queue::commands_map> get_next_delta();
+		void push_delta(double delta, command_queue::commands_map commands);
+		command_queue::commands_map pop_commands();
+		void send_commands(command_queue::commands_map commands);
+		void request_train(std::string name);
 	};
 }

network/message.cpp

@@ -11,10 +11,8 @@ void network::message::deserialize(std::istream &stream)
 
 }
 
-void::network::delta_message::serialize(std::ostream &stream)
+void::network::command_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);
@@ -29,10 +27,8 @@ void::network::delta_message::serialize(std::ostream &stream)
 	}
 }
 
-void network::delta_message::deserialize(std::istream &stream)
+void network::command_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);
@@ -54,7 +50,7 @@ void network::delta_message::deserialize(std::istream &stream)
 	}
 }
 
-size_t network::delta_message::get_size()
+size_t network::command_message::get_size()
 {
 	size_t cmd_size = 4;
 
@@ -65,7 +61,41 @@ size_t network::delta_message::get_size()
 		}
 	}
 
-	return message::get_size() + cmd_size + 8;
+	return message::get_size() + cmd_size;
+}
+
+size_t network::delta_message::get_size()
+{
+	return command_message::get_size() + 8;
+}
+
+void network::delta_message::serialize(std::ostream &stream)
+{
+	sn_utils::ls_float64(stream, dt);
+
+	command_message::serialize(stream);
+}
+
+void network::delta_message::deserialize(std::istream &stream)
+{
+	dt = sn_utils::ld_float64(stream);
+
+	command_message::deserialize(stream);
+}
+
+void network::string_message::serialize(std::ostream &stream)
+{
+	sn_utils::s_str(stream, name);
+}
+
+void network::string_message::deserialize(std::istream &stream)
+{
+	name = sn_utils::d_str(stream);
+}
+
+size_t network::string_message::get_size()
+{
+	return message::get_size() + name.size() + 1;
 }
 
 std::shared_ptr<network::message> network::deserialize_message(std::istream &stream)
@@ -79,6 +109,18 @@ std::shared_ptr<network::message> network::deserialize_message(std::istream &str
 		m->deserialize(stream);
 		msg = m;
 	}
+	else if (type == message::CLIENT_COMMAND) {
+		auto m = std::make_shared<command_message>();
+		m->type = type;
+		m->deserialize(stream);
+		msg = m;
+	}
+	else if (type == message::REQUEST_SPAWN_TRAIN || type == message::SPAWN_TRAIN) {
+		auto m = std::make_shared<string_message>(type);
+		m->type = type;
+		m->deserialize(stream);
+		msg = m;
+	}
 	else {
 		msg = std::make_shared<message>(type);
 	}

network/message.h

@@ -12,7 +12,9 @@ namespace network
 			CONNECT_REQUEST = 0,
 			CONNECT_ACCEPT,
 			STEP_INFO,
-			VEHICLE_COMMAND,
+			CLIENT_COMMAND,
+			REQUEST_SPAWN_TRAIN,
+			SPAWN_TRAIN,
 			TYPE_MAX
 		};
 
@@ -24,12 +26,34 @@ namespace network
 		virtual size_t get_size() { return 2; }
 	};
 
-	struct delta_message : public message
+	struct command_message : public message
 	{
-		delta_message() : message(STEP_INFO) {}
+		command_message() : message(CLIENT_COMMAND) {}
+		command_message(type_e type) : message(type) {}
+
+		command_queue::commands_map commands;
+
+		virtual void serialize(std::ostream &stream) override;
+		virtual void deserialize(std::istream &stream) override;
+		virtual size_t get_size() override;
+	};
+
+	struct delta_message : public command_message
+	{
+		delta_message() : command_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;
+	};
+
+	struct string_message : public message
+	{
+		string_message(type_e type) : message(type) {}
+
+		std::string name;
 
 		virtual void serialize(std::ostream &stream) override;
 		virtual void deserialize(std::istream &stream) override;

network/network.cpp

@@ -3,6 +3,7 @@
 #include "Logs.h"
 #include "sn_utils.h"
 #include "Timer.h"
+#include "application.h"
 
 void network::connection::connected()
 {
@@ -32,19 +33,35 @@ void network::connection::message_received(std::shared_ptr<message> &msg)
 	{
 		WriteLog("accept received", logtype::net);
 	}
+	else if (msg->type == message::CLIENT_COMMAND)
+	{
+		auto cmd = std::dynamic_pointer_cast<command_message>(msg);
+		for (auto const &kv : cmd->commands)
+			client_commands_queue.emplace(kv);
+	}
 	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));
 	}
+	else if (msg->type == message::REQUEST_SPAWN_TRAIN)
+	{
+		auto req = std::dynamic_pointer_cast<string_message>(msg);
+		Application.request_train(req->name);
+	}
+	else if (msg->type == message::SPAWN_TRAIN)
+	{
+		auto req = std::dynamic_pointer_cast<string_message>(msg);
+		Application.spawn_train(req->name);
+	}
 }
 
-std::tuple<double, command_queue::commanddatasequence_map> network::connection::get_next_delta()
+std::tuple<double, command_queue::commands_map> network::connection::get_next_delta()
 {
 	if (delta_queue.empty()) {
 		return std::tuple<double,
-		        command_queue::commanddatasequence_map>(0.0, command_queue::commanddatasequence_map());
+		        command_queue::commands_map>(0.0, command_queue::commands_map());
 	}
 
 	///auto now = std::chrono::high_resolution_clock::now();
@@ -66,6 +83,13 @@ std::tuple<double, command_queue::commanddatasequence_map> network::connection::
 	//}
 }
 
+command_queue::commands_map network::connection::pop_commands()
+{
+	command_queue::commands_map map(client_commands_queue);
+	client_commands_queue.clear();
+	return map;
+}
+
 void network::connection::data_received(std::string &buffer)
 {
 	std::istringstream body(buffer);
@@ -87,7 +111,7 @@ void network::connection::send_message(std::shared_ptr<message> msg)
 	send_data(buf);
 }
 
-void network::server::push_delta(double dt, command_queue::commanddatasequence_map commands)
+void network::server::push_delta(double dt, command_queue::commands_map commands)
 {
 	std::shared_ptr<delta_message> msg = std::make_shared<delta_message>();
 	msg->dt = dt;
@@ -97,7 +121,46 @@ void network::server::push_delta(double dt, command_queue::commanddatasequence_m
 		c->send_message(msg);
 }
 
-std::tuple<double, command_queue::commanddatasequence_map> network::client::get_next_delta()
+void network::server::notify_train(std::string name)
+{
+	std::shared_ptr<string_message> msg = std::make_shared<string_message>(message::SPAWN_TRAIN);
+	msg->name = name;
+
+	for (auto c : clients)
+		c->send_message(msg);
+}
+
+command_queue::commands_map network::server::pop_commands()
+{
+	command_queue::commands_map map;
+	for (auto c : clients) {
+		command_queue::commands_map cmap = c->pop_commands();
+		for (auto const &kv : cmap) {
+			auto lookup = map.emplace(kv.first, command_queue::commanddata_sequence());
+			for (command_data const &data : kv.second)
+				lookup.first->second.emplace_back(data);
+		}
+	}
+	return map;
+}
+
+std::tuple<double, command_queue::commands_map> network::client::get_next_delta()
 {
 	return conn->get_next_delta();
 }
+
+void network::client::send_commands(command_queue::commands_map commands)
+{
+	std::shared_ptr<command_message> msg = std::make_shared<command_message>();
+	msg->commands = commands;
+
+	conn->send_message(msg);
+}
+
+void network::client::request_train(std::string name)
+{
+	std::shared_ptr<string_message> msg = std::make_shared<string_message>(message::REQUEST_SPAWN_TRAIN);
+	msg->name = name;
+
+	conn->send_message(msg);
+}

network/network.h

@@ -18,6 +18,8 @@ namespace network
 		    std::pair<std::chrono::high_resolution_clock::time_point,
 		    std::shared_ptr<delta_message>>> delta_queue;
 
+		command_queue::commands_map client_commands_queue;
+
 		//std::chrono::high_resolution_clock::time_point last_time;
 		//double accum = -1.0;
 
@@ -31,7 +33,8 @@ namespace network
 		void send_message(std::shared_ptr<message> msg);
 		virtual void connected();
 
-		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
+		std::tuple<double, command_queue::commands_map> get_next_delta();
+		command_queue::commands_map pop_commands();
 	};
 
 	class server
@@ -40,7 +43,9 @@ namespace network
 		std::vector<std::shared_ptr<connection>> clients;
 
 	public:
-		void push_delta(double dt, command_queue::commanddatasequence_map commands);
+		void push_delta(double dt, command_queue::commands_map commands);
+		command_queue::commands_map pop_commands();
+		void notify_train(std::string name);
 	};
 
 	class client
@@ -49,6 +54,8 @@ namespace network
 		std::shared_ptr<connection> conn;
 
 	public:
-		std::tuple<double, command_queue::commanddatasequence_map> get_next_delta();
+		std::tuple<double, command_queue::commands_map> get_next_delta();
+		void send_commands(command_queue::commands_map commands);
+		void request_train(std::string name);
 	};
 }