good start

Author: HeatXD

GekkoLib/include/backend.h

@@ -103,7 +103,7 @@ namespace Gekko {
 
 		bool CheckStatusActors();
 
-        void SendHealthCheck(Frame frame, u32 checksum);
+        void SendSessionHealth(Frame frame, u32 checksum);
 
 	public:
 		std::vector<std::unique_ptr<Player>> locals;
@@ -149,7 +149,9 @@ namespace Gekko {
 
         void OnInputAck(NetAddress& addr, NetPacket& pkt);
 
-        void OnHealthCheck(NetAddress& addr, NetPacket& pkt);
+        void OnSessionHealth(NetAddress& addr, NetPacket& pkt);
+
+        void OnNetworkHealth(NetAddress& addr, NetPacket& pkt);
 
 	private:
 		const u32 MAX_PLAYER_SEND_SIZE = 32;

GekkoLib/include/net.h

@@ -31,7 +31,8 @@ namespace Gekko {
         InputAck,
         SyncRequest,
         SyncResponse,
-        HealthCheck,
+        SessionHealth,
+        NetworkHealth
     };
 
     struct MsgHeader {
@@ -88,7 +89,17 @@ namespace Gekko {
         }
     };
 
-    struct HealthCheckMsg : MsgBody {
+    struct SessionHealthMsg : MsgBody {
+        Frame frame;
+        u32 checksum;
+
+        template <typename Archive, typename Self>
+        static void serialize(Archive& a, Self& s) {
+            a(s.frame, s.checksum);
+        }
+    };
+
+    struct NetworkHealthMsg : MsgBody {
         Frame frame;
         u32 checksum;
 

GekkoLib/src/backend.cpp

@@ -14,7 +14,8 @@ namespace
         zpp::serializer::make_type<Gekko::SyncMsg, zpp::serializer::make_id("Gekko::SyncMsg")>,
         zpp::serializer::make_type<Gekko::InputMsg, zpp::serializer::make_id("Gekko::InputMsg")>,
         zpp::serializer::make_type<Gekko::InputAckMsg, zpp::serializer::make_id("Gekko::InputAckMsg")>,
-        zpp::serializer::make_type<Gekko::HealthCheckMsg, zpp::serializer::make_id("Gekko::HealthCheckMsg")>
+        zpp::serializer::make_type<Gekko::SessionHealthMsg, zpp::serializer::make_id("Gekko::SessionHealthMsg")>,
+        zpp::serializer::make_type<Gekko::NetworkHealthMsg, zpp::serializer::make_id("Gekko::NetworkHealthMsg")>
     > _;
 }
 
@@ -105,7 +106,7 @@ void Gekko::MessageSystem::SendPendingOutput(GekkoNetAdapter* host)
                 SendDataToAll(pkt.get(), host, true);
             }
 		}
-        else if (pkt->pkt.header.type == HealthCheck) {
+        else if (pkt->pkt.header.type == SessionHealth) {
             // send to remotes
             SendDataToAll(pkt.get(), host);
             // send to spectators
@@ -287,15 +288,15 @@ bool Gekko::MessageSystem::CheckStatusActors()
 	return result == 0;
 }
 
-void Gekko::MessageSystem::SendHealthCheck(Frame frame, u32 checksum)
+void Gekko::MessageSystem::SendSessionHealth(Frame frame, u32 checksum)
 {
     _pending_output.push(std::make_unique<NetData>());
     auto& message = _pending_output.back();
 
     // the address and magic is set later so dont worry about it now
-    message->pkt.header.type = HealthCheck;
+    message->pkt.header.type = SessionHealth;
 
-    auto body = std::make_unique<HealthCheckMsg>();
+    auto body = std::make_unique<SessionHealthMsg>();
     body->frame = frame;
     body->checksum = checksum;
 
@@ -453,8 +454,11 @@ void Gekko::MessageSystem::ParsePacket(NetAddress& addr, NetPacket& pkt)
         case InputAck:
             OnInputAck(addr, pkt);
             return;
-        case HealthCheck:
-            OnHealthCheck(addr, pkt);
+        case SessionHealth:
+            OnSessionHealth(addr, pkt);
+            return;
+        case NetworkHealth:
+            OnNetworkHealth(addr, pkt);
             return;
         default:
             printf("cannot process an unknown event!\n");
@@ -592,9 +596,9 @@ void Gekko::MessageSystem::OnInputAck(NetAddress& addr, NetPacket& pkt)
     }
 }
 
-void Gekko::MessageSystem::OnHealthCheck(NetAddress& addr, NetPacket& pkt)
+void Gekko::MessageSystem::OnSessionHealth(NetAddress& addr, NetPacket& pkt)
 {
-    auto body = (HealthCheckMsg*)pkt.body.get();
+    auto body = (SessionHealthMsg*)pkt.body.get();
 
     const Frame frame = body->frame;
     const u32 checksum = body->checksum;
@@ -616,6 +620,11 @@ void Gekko::MessageSystem::OnHealthCheck(NetAddress& addr, NetPacket& pkt)
     }
 }
 
+void Gekko::MessageSystem::OnNetworkHealth(NetAddress& addr, NetPacket& pkt)
+{
+    // TODO
+}
+
 void Gekko::MessageSystem::AddPendingInput(bool spectator)
 {
     u64 now = TimeSinceEpoch();

GekkoLib/src/gekko.cpp

@@ -282,7 +282,7 @@ void Gekko::Session::SendHealthCheck()
 
     _msg.local_health[confirmed] = sav->checksum;
 
-    _msg.SendHealthCheck(confirmed, sav->checksum);
+    _msg.SendSessionHealth(confirmed, sav->checksum);
 
     for (auto iter = _msg.local_health.begin();
         iter != _msg.local_health.end(); ) {

GekkoLib/src/gekkonet.cpp

@@ -110,7 +110,7 @@ static GekkoNetResult** asio_receive(int* length) {
     while (true) {
         const u32 len = (u32)_socket->receive_from(asio::buffer(_buffer), _remote, 0, _ec);
         if (_ec && _ec != asio::error::would_block) {
-            std::cout << "receive failed: " << _ec.message() << std::endl;
+            // std::cout << "receive failed: " << _ec.message() << std::endl;
             continue;
         }
         else if (!_ec) {