refactor(server): networking and fix mem leak.

srv/game/game.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <string.h>
 
 #include "game.h"
 #include "network/game_state_message.h"
@@ -13,8 +14,12 @@ Player* Game::add_player(BettolaLib::Network::Socket* socket) {
 void Game::remove_player(unsigned int player_id) {
   _players.erase(
     std::remove_if(_players.begin(), _players.end(),
-                   [player_id](const Player* player) {
-                      return player->get_id() == player_id;
+                   [player_id](Player* player) {
+                      if(player->get_id() == player_id) {
+                          delete player;
+                          return true;
+                      }
+                      return false;
                    }),
     _players.end());
 }
@@ -32,6 +37,7 @@ void Game::update_player_pos(unsigned int player_id, float x, float y) {
 void Game::broadcast_game_state(void) {
   BettolaLib::Network::GameStateMessage msg;
   msg.num_players = _players.size();
+  memset(msg.players, 0, sizeof(msg.players));
 
   for(size_t i = 0; i < _players.size(); ++i) {
     msg.players[i].player_id = _players[i]->get_id();
@@ -45,13 +51,8 @@ void Game::broadcast_game_state(void) {
 
   for(const auto& player : _players) {
     BettolaLib::Network::Socket& socket = player->get_socket();
-    /* Just quick fix the server crash for now. */
-    if(socket.send(&header, sizeof(header)) <= 0) {
-      /* TODO: Probably should handle this error by removing player.. */
-    }
-    if(socket.send(&msg, sizeof(msg)) <= 0) {
-      /* TODO: Probably should handle this error by removing player.. */
-    }
+    socket.send(&header, sizeof(header));
+    socket.send(&msg, sizeof(msg));
   }
 }
 

srv/main.cpp

@@ -1,6 +1,7 @@
 #include <cstddef>
 #include <cstdio>
 #include <chrono>
+#include <sys/select.h>
 #include <thread>
 #include <vector>
 #include <fcntl.h>
@@ -54,7 +55,26 @@ int main(void) {
 
   /* Main server loop. */
   while(true) {
-    /* Accept new connections. */
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(server_socket.get_sockfd(), &read_fds);
+    int max_fd = server_socket.get_sockfd();
+
+    for(const auto& client : client_sockets) {
+    FD_SET(client->get_sockfd(), &read_fds);
+      if(client->get_sockfd() > max_fd) {
+        max_fd = client->get_sockfd();
+      }
+    }
+
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000; /* 1ms */
+
+    int activity = select(max_fd+1, &read_fds, nullptr, nullptr, &tv);
+
+    if(activity > 0) {
+      if(FD_ISSET(server_socket.get_sockfd(), &read_fds)) {
         BettolaLib::Network::Socket* client_socket = server_socket.accept();
         if(client_socket != nullptr) {
           Player* new_player = game.add_player(client_socket);
@@ -67,25 +87,19 @@ int main(void) {
           unsigned int id = new_player->get_id();
           client_socket->send(&id, sizeof(id));
 
-      /* Set the client socket to non-blocking. */
           int client_flags = fcntl(client_socket->get_sockfd(), F_GETFL, 0);
-      if(client_flags == -1) {
-        perror("fcntl F_GETFL failed");
-        return 1;
-      }
           fcntl(client_socket->get_sockfd(), F_SETFL, client_flags | O_NONBLOCK);
 
           client_sockets.push_back(client_socket);
         }
+      }
 
-    /* Process messages from clients. */
       for(auto it = client_sockets.begin(); it != client_sockets.end();) {
         BettolaLib::Network::Socket* client = *it;
+        if(FD_ISSET(client->get_sockfd(), &read_fds)) {
           bool client_disconnected = false;
-
-      while(true) {
+          while (true) {
             BettolaLib::Network::MessageHeader header;
-        /* Non-blocking. */
             ssize_t bytes_received = client->recv(&header, sizeof(header));
 
             if(bytes_received == 0) {
@@ -94,7 +108,6 @@ int main(void) {
             }
 
             if(bytes_received < 0) {
-          /* No data to read.. */
               break;
             }
 
@@ -114,16 +127,21 @@ int main(void) {
             Player* player = game.get_player_by_socket(client);
             if(player) game.remove_player(player->get_id());
             it = client_sockets.erase(it);
+            delete client;
           } else {
             ++it;
           }
+        } else {
+          ++it;
+        }
+      }
     }
 
     /* Broadcase game state. */
     game.broadcast_game_state();
 
     /* Sleep for a short time to avoid busy-waiting. */
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000/60));
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
 
   server_socket.close(); /* Shouldn't reach here. */