refactor network packets

[carveJwlIkooP6JGAAIwe30JlM.git] / gameserver.c

diff --git a/gameserver.c b/gameserver.c
index afc0bc31a00743c840ecd2f7c354356cf016e847..5ed561249c707d3e132440a50ea9927788345379 100644 (file)
--- a/gameserver.c
+++ b/gameserver.c
@@ -17,6 +17,7 @@ static void inthandler( int signum ) {
 #include "highscores.c"
 #include "servermonitor_server.c"
 #include "vg/vg_opt.h"
+#include "network_common.h"
 
 static const u64 k_connection_unauthorized = 0xffffffffffffffff;
 
@@ -49,44 +50,51 @@ static void gameserver_send_to_all( int ignore,
    }
 }
 
-static void gameserver_populate_join_msg( int index, netmsg_playerjoin *msg ){
-   memset( msg, 0, sizeof(*msg) );
-   msg->inetmsg_id = k_inetmsg_playerjoin;
-   msg->index = index;
-   vg_strncpy( gameserver.clients[index].username, msg->username, 
-               sizeof(msg->username), k_strncpy_always_add_null );
-}
-
 static void gameserver_player_join( int index ){
    struct gameserver_client *joiner = &gameserver.clients[index];
    
-   netmsg_playerjoin join;
-   gameserver_populate_join_msg( index, &join );
+   netmsg_playerjoin join = { .inetmsg_id = k_inetmsg_playerjoin,
+                              .index = index };
    gameserver_send_to_all( index, &join, sizeof(join),
                            k_nSteamNetworkingSend_Reliable );
 
    /* update the joining user about current connections */
+
+   netmsg_playerusername *username = alloca( sizeof(netmsg_playerusername) + 
+                                             NETWORK_USERNAME_MAX );
+   username->inetmsg_id = k_inetmsg_playerusername;
+
    for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
       struct gameserver_client *client = &gameserver.clients[i];
 
       if( (i==index) || !client->active )
          continue;
 
-      netmsg_playerjoin init;
-      gameserver_populate_join_msg( i, &init );
-
+      /* join */
+      netmsg_playerjoin init = { .inetmsg_id = k_inetmsg_playerjoin,
+                                 .index = i };
+      SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+            hSteamNetworkingSockets, joiner->connection,
+            &init, sizeof(init), k_nSteamNetworkingSend_Reliable, NULL );
+
+      /* username */
+      username->index = i;
+      u32 chs = vg_strncpy( client->username, username->name, 
+                            NETWORK_USERNAME_MAX,
+                            k_strncpy_always_add_null );
+      u32 size = sizeof(netmsg_playerusername) + chs + 1;
       SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
             hSteamNetworkingSockets, joiner->connection,
-            &join, sizeof(join), k_nSteamNetworkingSend_Reliable, NULL );
+            username, size, k_nSteamNetworkingSend_Reliable, NULL );
    }
 }
 
 static void gameserver_player_leave( int index ){
-
    netmsg_playerjoin leave;
    leave.inetmsg_id = k_inetmsg_playerleave;
    leave.index = index;
 
+   vg_info( "Player leave (%d)\n", index );
    gameserver_send_to_all( index, &leave, sizeof(leave),
                            k_nSteamNetworkingSend_Reliable );
 }
@@ -296,29 +304,45 @@ static int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
 static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
    netmsg_blank *tmp = msg->m_pData;
 
+   int client_id = gameserver_client_index( msg->m_conn );
+   if( client_id == -1 ) return;
+
    if( tmp->inetmsg_id == k_inetmsg_playerusername ){
-      if( !packet_minsize( msg, sizeof(netmsg_playerusername) ))
+      if( !packet_minsize( msg, sizeof(netmsg_playerusername)+1 ))
          return;
       
-      int client_id = gameserver_client_index( msg->m_conn );
-      if( client_id != -1 ){
-         struct gameserver_client *client = &gameserver.clients[ client_id ];
-         netmsg_playerusername *src = msg->m_pData;
-
-         vg_strncpy( src->username, client->username, sizeof(client->username),
-                     k_strncpy_always_add_null );
-
-         /* update other users about this change */
-         netmsg_playerusername msg;
-         memset( &msg, 0, sizeof(msg) );
-         msg.inetmsg_id = k_inetmsg_playerusername;
-         msg.index = client_id;
-         vg_strncpy( client->username, msg.username, sizeof(msg.username),
-                     k_strncpy_always_add_null );
-
-         gameserver_send_to_all( client_id, &msg, sizeof(msg), 
-                                 k_nSteamNetworkingSend_Reliable );
-      }
+      struct gameserver_client *client = &gameserver.clients[ client_id ];
+      netmsg_playerusername *src = msg->m_pData;
+
+      u32 name_len = network_msgstring( src->name, msg->m_cbSize, 
+                                        sizeof(netmsg_playerusername),
+                                        client->username, 
+                                        NETWORK_USERNAME_MAX );
+
+      /* update other users about this change */
+      netmsg_playerusername *prop = alloca(sizeof(netmsg_playerusername)+
+                                             NETWORK_USERNAME_MAX );
+                                           
+      prop->inetmsg_id = k_inetmsg_playerusername;
+      prop->index = client_id;
+      u32 chs = vg_strncpy( client->username, prop->name, name_len,
+                            k_strncpy_always_add_null );
+
+      vg_info( "client #%d changed name to: %s\n", client_id, 
+               client->username );
+
+      u32 propsize = sizeof(netmsg_playerusername) + chs + 1;
+      gameserver_send_to_all( client_id, prop, propsize,
+                              k_nSteamNetworkingSend_Reliable );
+   }
+   else if( tmp->inetmsg_id == k_inetmsg_playerframe ){
+      /* propogate */
+
+      netmsg_playerframe *frame = alloca(msg->m_cbSize);
+      memcpy( frame, msg->m_pData, msg->m_cbSize );
+      frame->client = client_id;
+      gameserver_send_to_all( client_id, frame, msg->m_cbSize, 
+                              k_nSteamNetworkingSend_Unreliable );
    }
 }