X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=gameserver.c;h=e36e60f704c345030c9189fab49d27ab42046353;hb=6e6c7f31b8f17af3814727109e48fc6f85ef04b1;hp=9ac4b2f05ef3bbed94ee7e207058d11ddae88c54;hpb=4bf136afb77a4c2937952b9152165f1ddcd2da9d;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/gameserver.c b/gameserver.c
index 9ac4b2f..e36e60f 100644
--- a/gameserver.c
+++ b/gameserver.c
@@ -54,6 +54,18 @@ static void gameserver_send_to_all( int ignore,
    }
 }
 
+static void gameserver_send_version_to_client( int index ){
+   struct gameserver_client *client = &gameserver.clients[index];
+
+   netmsg_version version;
+   version.inetmsg_id = k_inetmsg_version;
+   version.version = NETWORK_SKATERIFT_VERSION;
+   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+         hSteamNetworkingSockets, client->connection,
+         &version, sizeof(netmsg_version), 
+         k_nSteamNetworkingSend_Reliable, NULL );
+}
+
 /*
  * handle server update that client #'index' has joined
  */
@@ -68,8 +80,10 @@ static void gameserver_player_join( int index ){
                            k_nSteamNetworkingSend_Reliable );
 
    /* 
-    * update the joining user about current connections 
+    * update the joining user about current connections and our version
     */
+   gameserver_send_version_to_client( index );
+
    netmsg_playerusername *username = 
       alloca( sizeof(netmsg_playerusername) + NETWORK_USERNAME_MAX );
    username->inetmsg_id = k_inetmsg_playerusername;
@@ -78,6 +92,9 @@ static void gameserver_player_join( int index ){
       alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
    item->inetmsg_id = k_inetmsg_playeritem;
 
+   netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+   region->inetmsg_id = k_inetmsg_region;
+
    for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
       struct gameserver_client *client = &gameserver.clients[i];
 
@@ -102,7 +119,7 @@ static void gameserver_player_join( int index ){
 
       /* items */
       for( int j=0; j<k_netmsg_playeritem_max; j++ ){
-         chs = vg_strncpy( client->items[j], item->uid, ADDON_UID_MAX, 
+         chs = vg_strncpy( client->items[j].uid, item->uid, ADDON_UID_MAX, 
                            k_strncpy_always_add_null );
          item->type_index = j;
          item->client = i;
@@ -110,6 +127,17 @@ static void gameserver_player_join( int index ){
          gameserver_send_to_client( index, item, size,
                                     k_nSteamNetworkingSend_Reliable );
       }
+
+      /* region */
+      
+      region->client = i;
+      region->flags = client->region_flags;
+      u32 l = vg_strncpy( client->region, region->loc, NETWORK_REGION_MAX, 
+                          k_strncpy_always_add_null );
+      size = sizeof(netmsg_region) + l + 1;
+
+      gameserver_send_to_client( index, region, size,
+                                 k_nSteamNetworkingSend_Reliable );
    }
 }
 
@@ -131,6 +159,8 @@ static void gameserver_player_leave( int index ){
                            k_nSteamNetworkingSend_Reliable );
 }
 
+static void gameserver_update_all_knowledge( int client, int clear );
+
 /*
  * Deletes client at index and disconnects the connection handle if it was 
  * set.
@@ -146,6 +176,7 @@ static void remove_client( int index ){
             NULL, 1 );
    }
    memset( client, 0, sizeof(struct gameserver_client) );
+   gameserver_update_all_knowledge( index, 1 );
 }
 
 /*
@@ -189,11 +220,6 @@ static void handle_new_connection( HSteamNetConnection conn ){
       
       SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
             hSteamNetworkingSockets, conn, index );
-      
-      if( gameserver.auth_mode != eServerModeAuthentication ){
-         client->steamid = k_steamid_max;
-         gameserver_player_join( index );
-      }
    }
    else{
       vg_warn( "Error accepting connection (id: %u)\n", conn );
@@ -263,14 +289,52 @@ static void on_connect_status( CallbackMsg_t *msg ){
    }
 }
 
+static void gameserver_rx_version( SteamNetworkingMessage_t *msg ){
+   netmsg_version *version = msg->m_pData;
+
+   int client_id = gameserver_conid( msg->m_conn );
+   if( client_id == -1 ) {
+      vg_warn( "Recieved version from unkown connection (%u)\n", msg->m_conn );
+      SteamAPI_ISteamNetworkingSockets_CloseConnection( 
+            hSteamNetworkingSockets, msg->m_conn,
+            k_ESteamNetConnectionEnd_Misc_InternalError,
+            NULL, 1 );
+      return;
+   }
+
+   struct gameserver_client *client = &gameserver.clients[ client_id ];
+
+   if( client->version ){
+      vg_warn( "Already have version for this client (%d conn: %u)", 
+               client_id, msg->m_conn );
+      return;
+   }
+
+   client->version = version->version;
+
+   if( client->version != NETWORK_SKATERIFT_VERSION ){
+      gameserver_send_version_to_client( client_id );
+      remove_client( client_id );
+      return;
+   }
+
+   /* this is the sign on point for non-auth servers,
+    * for auth servers it comes at the end of rx_auth 
+    */
+   if( gameserver.auth_mode != eServerModeAuthentication ){
+      client->steamid = k_steamid_max;
+      gameserver_player_join( client_id );
+   }
+}
+
 /* 
  * recieve auth ticket from connection. will only accept it if we've added them
  * to the client list first.
  */
 static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){
    if( gameserver.auth_mode != eServerModeAuthentication ){
-      vg_error( "Running server without authentication. "
-                "Connection %u tried to authenticate.\n", msg->m_conn );
+      vg_warn( "Running server without authentication. "
+               "Connection %u tried to authenticate.\n", msg->m_conn );
       return;
    }
 
@@ -278,21 +342,30 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){
    if( client_id == -1 ) {
       vg_warn( "Recieved auth ticket from unkown connection (%u)\n", 
                msg->m_conn );
+      SteamAPI_ISteamNetworkingSockets_CloseConnection( 
+            hSteamNetworkingSockets, msg->m_conn,
+            k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
       return;
    }
 
    struct gameserver_client *client = &gameserver.clients[ client_id ];
-
    if( client->steamid ){
       vg_warn( "Already authorized this user but another app ticket was sent"
                " again (%d conn: %u)\n", client_id, msg->m_conn );
       return;
    }
 
+   if( client->version == 0 ){
+      vg_error( "Client has not sent their version yet (%u)\n", msg->m_conn );
+      remove_client( client_id );
+      return;
+   }
+
    vg_low( "Attempting to verify user\n" );
 
    if( msg->m_cbSize < sizeof(netmsg_auth) ){
       vg_error( "Malformed auth ticket, too small (%u)\n", msg->m_conn );
+      remove_client( client_id );
       return;
    }
 
@@ -301,7 +374,8 @@ static void gameserver_rx_auth( SteamNetworkingMessage_t *msg ){
    if( msg->m_cbSize < sizeof(netmsg_auth)+auth->ticket_length ||
        auth->ticket_length > 1024 ){
       vg_error( "Malformed auth ticket, ticket_length incorrect (%u)\n",
-            auth->ticket_length );
+                  auth->ticket_length );
+      remove_client( client_id );
       return;
    }
 
@@ -375,6 +449,103 @@ static void gameserver_update_db_username( db_request *db_req ){
    db_updateuser( inf->steamid, inf->username, admin );
 }
 
+static int gameserver_item_eq( struct gameserver_item *ia, 
+                               struct gameserver_item *ib ){
+   if( ia->hash == ib->hash )
+      if( !strcmp(ia->uid,ib->uid) )
+         return 1;
+
+   return 0;
+}
+
+/*
+ * Match addons between two player IDs. if clear is set, then the flags between
+ * those two IDs will all be set to 0.
+ */
+static void gameserver_update_knowledge_table( int client0, int client1, 
+                                               int clear ){
+   u32 idx = network_pair_index( client0, client1 );
+
+   struct gameserver_client *c0 = &gameserver.clients[client0],
+                            *c1 = &gameserver.clients[client1];
+
+   u8 flags = 0x00;
+
+   if( !clear ){
+      if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world0],
+                             &c1->items[k_netmsg_playeritem_world0]))
+         flags |= CLIENT_KNOWLEDGE_SAME_WORLD0;
+
+      if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world1],
+                             &c1->items[k_netmsg_playeritem_world1]))
+         flags |= CLIENT_KNOWLEDGE_SAME_WORLD1;
+   }
+
+   gameserver.client_knowledge_mask[idx] = flags;
+}
+
+/*
+ * If a change has been made on this client, then it will adjust the entire
+ * table of other players. if clear is set, all references to client will be set
+ * to 0.
+ */
+static void gameserver_update_all_knowledge( int client, int clear ){
+   for( int i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+      if( i == client )
+         continue;
+
+      struct gameserver_client *ci = &gameserver.clients[i];
+
+      if( ci->steamid )
+         gameserver_update_knowledge_table( client, i, clear );
+   }
+}
+
+static void gameserver_propogate_player_frame( int client_id, 
+                                               netmsg_playerframe *frame, 
+                                               u32 size ){
+   u32 basic_size = sizeof(netmsg_playerframe) + ((24*3)/8);
+   netmsg_playerframe *full = alloca(size),
+                      *basic= alloca(basic_size);
+
+   memcpy( full, frame, size );
+   memcpy( basic, frame, basic_size );
+
+   full->client = client_id;
+   basic->client = client_id;
+   basic->subsystem = 4; /* (.._basic_info: 24f*3 animator ) */
+   basic->sound_effects = 0;
+
+   struct gameserver_client *c0 = &gameserver.clients[client_id];
+   c0->instance = frame->instance_id;
+
+   for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
+      if( i == client_id )
+         continue;
+
+      struct gameserver_client *ci = &gameserver.clients[i];
+
+      int send_full = 0;
+
+      if( c0->instance == ci->instance ){
+         u32 k_index = network_pair_index( client_id, i );
+         u8 k_mask = gameserver.client_knowledge_mask[ k_index ];
+         
+         if( (k_mask & (CLIENT_KNOWLEDGE_SAME_WORLD0<<c0->instance)) )
+            send_full = 1;
+      }
+
+      if( send_full ){
+         gameserver_send_to_client( i, full, size, 
+                                    k_nSteamNetworkingSend_Unreliable );
+      }
+      else {
+         gameserver_send_to_client( i, basic, basic_size, 
+                                    k_nSteamNetworkingSend_Unreliable );
+      }
+   }
+}
+
 static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
    netmsg_blank *tmp = msg->m_pData;
 
@@ -420,12 +591,8 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
       db_send_request( call );
    }
    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 );
+      gameserver_propogate_player_frame( client_id, 
+                                         msg->m_pData, msg->m_cbSize );
    }
    else if( tmp->inetmsg_id == k_inetmsg_playeritem ){
       netmsg_playeritem *item = msg->m_pData;
@@ -438,7 +605,7 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
          return;
       }
       
-      char *dest = client->items[ item->type_index ];
+      char *dest = client->items[ item->type_index ].uid;
 
       network_msgstring( item->uid, msg->m_cbSize, sizeof(netmsg_playeritem),
                          dest, ADDON_UID_MAX );
@@ -450,6 +617,8 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
                                 [k_netmsg_playeritem_world0]="world0",
                                 [k_netmsg_playeritem_world1]="world1"
                }[item->type_index], item->uid );
+
+      gameserver_update_all_knowledge( client_id, 0 );
                            
       /* propogate */
       netmsg_playeritem *prop = alloca(msg->m_cbSize);
@@ -458,6 +627,39 @@ static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
       gameserver_send_to_all( client_id, prop, msg->m_cbSize, 
                               k_nSteamNetworkingSend_Reliable );
    }
+   else if( tmp->inetmsg_id == k_inetmsg_chat ){
+      netmsg_chat *chat = msg->m_pData,
+                  *prop = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
+      prop->inetmsg_id = k_inetmsg_chat;
+      prop->client = client_id;
+
+      u32 l = network_msgstring( chat->msg, msg->m_cbSize, sizeof(netmsg_chat),
+                                 prop->msg, NETWORK_MAX_CHAT );
+      vg_info( "[%d]: %s\n", client_id, prop->msg );
+
+      gameserver_send_to_all( client_id, prop, sizeof(netmsg_chat)+l+1, 
+                              k_nSteamNetworkingSend_Reliable );
+   }
+   else if( tmp->inetmsg_id == k_inetmsg_region ){
+      netmsg_region *region = msg->m_pData,
+                    *prop = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+
+      prop->inetmsg_id = k_inetmsg_region;
+      prop->client = client_id;
+      prop->flags = region->flags;
+
+      u32 l = network_msgstring( 
+            region->loc, msg->m_cbSize, sizeof(netmsg_region),
+            client->region, NETWORK_REGION_MAX );
+      client->region_flags = region->flags;
+
+      l = vg_strncpy( client->region, prop->loc, NETWORK_REGION_MAX, 
+                      k_strncpy_always_add_null );
+
+      gameserver_send_to_all( client_id, prop, sizeof(netmsg_region)+l+1, 
+                              k_nSteamNetworkingSend_Reliable );
+      vg_info( "client %d moved to region: %s\n", client_id, client->region );
+   }
    else {
       vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
                tmp->inetmsg_id );
@@ -505,7 +707,7 @@ static enum request_status gameserver_cat_table(
    vg_strnull( &q, buf, 512 );
    vg_strcat( &q, "SELECT * FROM \"" );
    vg_strcat( &q, table_name );
-   vg_strcat( &q, "\" ORDER BY time DESC LIMIT 10;" );
+   vg_strcat( &q, "\" ORDER BY time ASC LIMIT 10;" );
    if( !vg_strgood(&q) )
       return k_request_status_out_of_memory;
 
@@ -565,11 +767,11 @@ static void gameserver_process_user_request( db_request *db_req ){
    vg_msg_init( &data, req->q, msg->m_cbSize - sizeof(netmsg_request) );
 
    /* create response packet */
-   netmsg_request *res = alloca( sizeof(netmsg_request) + 512 );
+   netmsg_request *res = alloca( sizeof(netmsg_request) + NETWORK_REQUEST_MAX );
    res->inetmsg_id = k_inetmsg_response;
    res->id = req->id;
    vg_msg body;
-   vg_msg_init( &body, res->q, 512 );
+   vg_msg_init( &body, res->q, NETWORK_REQUEST_MAX );
 
    const char *endpoint = vg_msg_getkvstr( &data, "endpoint" );
 
@@ -704,6 +906,9 @@ static void poll_connections(void){
          else{
             if( tmp->inetmsg_id == k_inetmsg_auth )
                gameserver_rx_auth( msg );
+            else if( tmp->inetmsg_id == k_inetmsg_version ){
+               gameserver_rx_version( msg );
+            }
             else {
                vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
                         tmp->inetmsg_id );
@@ -719,6 +924,7 @@ static u64 seconds_to_server_ticks( double s ){
 }
 
 static void test_runner( db_request *req ){
+#if 0
    vg_warn( "RUNNER\n" );
    char table[DB_TABLE_UID_MAX];
    if( db_get_highscore_table_name( "sr002-local-mp_mtzero", 
@@ -729,8 +935,16 @@ static void test_runner( db_request *req ){
          vg_success( "Returned time: %u\n", v );
       }
    }
+#endif
 }
 
+#define SIDELOAD
+#ifdef SIDELOAD
+#include "gameserver_sideload.h"
+static int bsideload = 0;
+const char *sideload_path = NULL;
+#endif
+
 int main( int argc, char *argv[] ){
    signal( SIGINT, inthandler );
    signal( SIGQUIT, inthandler );
@@ -741,7 +955,12 @@ int main( int argc, char *argv[] ){
       if( vg_long_opt( "noauth" ) )
          gameserver.auth_mode = eServerModeNoAuthentication;
 
-      /* TODO: Options to override, ammend, remove etc */
+#ifdef SIDELOAD
+      if( (arg = vg_long_opt_arg( "sideload" )) ){
+         sideload_path = arg;
+         bsideload = 1;
+      }
+#endif
    }
    
    vg_set_mem_quota( 80*1024*1024 );
@@ -754,6 +973,15 @@ int main( int argc, char *argv[] ){
       db_send_request(req);
    }
 
+#ifdef SIDELOAD
+   if( bsideload ){
+      sideload( sideload_path );
+      db_kill();
+      db_free();
+      return 0;
+   }
+#endif
+
    monitor_start_server(); /* UNIX socket monitor */
 
    /* steamworks init