X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=network.c;h=92389016c49a7a5240e03ff0794bc674ac6bfd05;hb=8090b8da9ce1397ba47d7e2d91b4f1716f708f25;hp=838653c33e8208b1174aa319e2a0b1977933bfe4;hpb=ce0205fd929e5fb1446f8c52fcab344884d82569;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/network.c b/network.c
index 838653c..9238901 100644
--- a/network.c
+++ b/network.c
@@ -3,6 +3,9 @@
 #include "network_msg.h"
 #include "network_common.h"
 #include "player_remote.h"
+#include "world.h"
+#include "world_sfd.h"
+#include "world_routes.h"
 
 static void scores_update(void);
 
@@ -54,101 +57,163 @@ static void request_auth_ticket(void){
       SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
 }
 
-#if 0
-static void send_score_request(void){
-   vg_info( "Requesting scores\n" );
-   netmsg_scores_request req;
-   req.inetmsg_id = k_inetmsg_scores_request;
+static void network_send_username(void){
+   if( !network_connected() )
+      return;
+
+   netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
+                                           NETWORK_USERNAME_MAX );
+   update->inetmsg_id = k_inetmsg_playerusername;
+   update->index = 0xff;
+
+   ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
+   const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
+   u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
 
    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
          hSteamNetworkingSockets, network_client.remote, 
-         &req, sizeof(netmsg_scores_request),
+         update, sizeof(netmsg_playerusername)+chs+1,
          k_nSteamNetworkingSend_Reliable, NULL );
 }
 
-static void send_score_update(void){
-   vg_info( "Sending scores\n" );
-   u32 size = sizeof(netmsg_set_score) + 
-                  vg_list_size(track_infos)*sizeof(struct netmsg_score_record);
-   netmsg_set_score *setscore = alloca( size );
-   setscore->inetmsg_id = k_inetmsg_set_score;
-
-   int count = 0;
-   for( u32 i=0; i<vg_list_size(track_infos); i++ ){
-      if( track_infos[i].push ){
-         track_infos[i].push = 0;
-
-#if 0
-         highscore_record *user_record = highscore_find_user_record( 0, i );
-
-         if( !user_record ){
-            vg_error( "No score set but tried to upload for track %u\n", i );
-            continue;
-         }
-#endif
-         highscore_record *user_record = &track_infos[i].record;
-
-         setscore->records[count].trackid = i;
-         setscore->records[count].playerid = 0;
-         setscore->records[count].points = user_record->points;
-         setscore->records[count].time = user_record->time;
-
-         count ++;
+static void network_send_request( netmsg_request *req, vg_msg *body,
+                                  void (*callback)( 
+                                     netmsg_request *res, vg_msg *body, 
+                                     u64 userdata),
+                                  u64 userdata ){
+   u32 len = 0;
+   if( body ){
+      len = body->cur.co;
+      vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
+      vg_msg_print( body, len );
+
+      if( body->error != k_vg_msg_error_OK ){
+         vg_error( "Body not OK\n" );
+         return;
       }
    }
 
-   if( count == 0 ) return;
-   u32 send_size = sizeof(netmsg_set_score) +
-                  count*sizeof(struct netmsg_score_record);
-   setscore->record_count = count;
+   if( callback ){
+      req->id = vg_pool_lru( &network_client.request_pool );
+      if( req->id ){
+         vg_pool_watch( &network_client.request_pool, req->id );
+         struct network_request *pn = 
+            vg_pool_item( &network_client.request_pool, req->id );
+         pn->callback = callback;
+         pn->sendtime = vg.time_real;
+         pn->userdata = userdata;
+      }
+      else{
+         vg_error( "Unable to send request. Pool is full.\n" );
+         return;
+      }
+   }
+   else
+      req->id = 0;
 
    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
-         hSteamNetworkingSockets, network_client.remote, setscore, send_size,
+         hSteamNetworkingSockets, network_client.remote, 
+         req, sizeof(netmsg_request)+len,
          k_nSteamNetworkingSend_Reliable, NULL );
 }
 
-static void send_nickname(void){
-   netmsg_set_nickname nick;
-   nick.inetmsg_id = k_inetmsg_set_nickname;
+static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
+                                         u64 userdata ){
+   world_instance *world = world_current_instance();
 
-   memset( nick.nickname, 0, 16 );
-   vg_strncpy( steam_username_at_startup, nick.nickname, 16,
-               k_strncpy_allow_cutoff );
-   
-   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
-         hSteamNetworkingSockets, network_client.remote, 
-         &nick, sizeof(netmsg_set_nickname),
-         k_nSteamNetworkingSend_Reliable, NULL );
+   world_routes_recv_scoreboard( world, body, userdata, res->status );
+   if( userdata == world_sfd.active_route_board )
+      world_sfd_compile_active_scores();
+}
+
+
+
+/* mod_uid: world mod uid,
+ * route_uid: run name (just a string)
+ * week: 
+ *   0   ALL TIME
+ *   1   CURRENT WEEK
+ *   2   ALL TIME + CURRENT WEEK
+ *   .
+ *   10+ specific week index
+ */
+static void network_request_scoreboard( const char *mod_uid, 
+                                        const char *route_uid,
+                                        u32 week, u64 userdata ){
+   if( !network_connected() ) 
+      return;
 
-   network_client.name_update = 0;
+   netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
+   req->inetmsg_id = k_inetmsg_request;
+
+   vg_msg data;
+   vg_msg_init( &data, req->q, 512 );
+   vg_msg_wkvstr( &data, "endpoint", "scoreboard" );
+   vg_msg_wkvstr( &data, "mod", mod_uid );
+   vg_msg_wkvstr( &data, "route", route_uid );
+   vg_msg_wkvu32( &data, "week", week );
+   network_send_request( req, &data, network_scoreboard_callback, userdata );
 }
-#endif
 
-#if 0
-static void server_routine_update(void){
-   send_score_update();
-   send_score_request();
+static void network_publish_callback( netmsg_request *res, vg_msg *body,
+                                      u64 userdata ){
+   if( res->status != k_request_status_ok ){
+      vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
+   }
 }
-#endif
 
-static void network_send_username(void){
-   netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
-                                           NETWORK_USERNAME_MAX );
-   update->inetmsg_id = k_inetmsg_playerusername;
-   update->index = 0xff;
+static void network_publish_laptime( const char *mod_uid, 
+                                     const char *route_uid, f64 lap_time ){
+   if( !network_connected() )
+      return;
 
-   ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
-   const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
-   u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
+   i32 time_centiseconds = lap_time * 100.0;
 
-   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
-         hSteamNetworkingSockets, network_client.remote, 
-         update, sizeof(netmsg_playerusername)+chs+1,
-         k_nSteamNetworkingSend_Reliable, NULL );
+   netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
+   req->inetmsg_id = k_inetmsg_request;
+
+   vg_msg data;
+   vg_msg_init( &data, req->q, 512 );
+   vg_msg_wkvstr( &data, "endpoint", "setlap" );
+   vg_msg_wkvstr( &data, "mod", mod_uid );
+   vg_msg_wkvstr( &data, "route", route_uid );
+   vg_msg_wkvi32( &data, "time", time_centiseconds );
+   network_send_request( req, &data, network_publish_callback, 0 );
+}
+
+static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
+   netmsg_blank *tmp = msg->m_pData;
+
+   if( tmp->inetmsg_id == k_inetmsg_request ){
+      
+   }
+   else if( tmp->inetmsg_id == k_inetmsg_response ){
+      netmsg_request *res = (netmsg_request *)msg->m_pData;
+
+      vg_msg *body = NULL;
+
+      vg_msg data;
+      if( res->status == k_request_status_ok ){
+         vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
+         vg_success( "Response to #%d:\n", (i32)res->id );
+         vg_msg_print( &data, data.max );
+         body = &data;
+      }
+      else {
+         vg_warn( "Server response to #%d: %d\n", (i32)res->id, res->status );
+      }
+
+      if( res->id ){
+         struct network_request *pn = 
+            vg_pool_item( &network_client.request_pool, res->id );
+         pn->callback( res, body, pn->userdata );
+         vg_pool_unwatch( &network_client.request_pool, res->id );
+      }
+   }
 }
 
 static void network_send_item( enum netmsg_playeritem_type type ){
-   if( !network_client.remote )
+   if( !network_connected() )
       return;
 
    netmsg_playeritem *item = 
@@ -160,10 +225,8 @@ static void network_send_item( enum netmsg_playeritem_type type ){
    if( (type == k_netmsg_playeritem_world0) ||
        (type == k_netmsg_playeritem_world1) ){
 
-      addon_reg *reg = world_static.addon_hub;
-
-      if( type == k_netmsg_playeritem_world1 )
-         reg = world_static.addon_client;
+      enum world_purpose purpose = type - k_netmsg_playeritem_world0;
+      addon_reg *reg = world_static.instance_addons[ purpose ];
 
       if( reg )
          addon_alias_uid( &reg->alias, item->uid );
@@ -201,13 +264,13 @@ static void network_send_item( enum netmsg_playeritem_type type ){
          hSteamNetworkingSockets, network_client.remote, 
          item, sizeof(netmsg_playeritem)+chs+1,
          k_nSteamNetworkingSend_Reliable, NULL );
-
 }
 
 static void network_disconnect(void){
    SteamAPI_ISteamNetworkingSockets_CloseConnection( 
          hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
    network_client.remote = 0;
+   network_client.state = k_ESteamNetworkingConnectionState_None;
 
    for( int i=0; i<vg_list_size(netplayers.list); i++ ){
       netplayers.list[i].active = 0;
@@ -228,6 +291,14 @@ static void on_server_connect_status( CallbackMsg_t *msg ){
             k_ESteamNetworkingConnectionState_Connected ){
          vg_success("  Connected to remote server.. authenticating\n");
 
+         /* send version info to server */
+         netmsg_version version;
+         version.inetmsg_id = k_inetmsg_version;
+         version.version = NETWORK_SKATERIFT_VERSION;
+         SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+               hSteamNetworkingSockets, network_client.remote, &version, 
+               sizeof(netmsg_version), k_nSteamNetworkingSend_Reliable, NULL );
+
          /* TODO: We should really wait to see if the server is in auth mode
           * first... */
          u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
@@ -240,18 +311,12 @@ static void on_server_connect_status( CallbackMsg_t *msg ){
          SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
                hSteamNetworkingSockets, network_client.remote, auth, size,
                k_nSteamNetworkingSend_Reliable, NULL );
-
-         network_send_username();
-
-         for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
-            network_send_item(i);
-         }
       }
       else if( info->m_info.m_eState == 
             k_ESteamNetworkingConnectionState_ClosedByPeer ){
 
          if( info->m_info.m_eEndReason == 
-               k_ESteamNetConnectionEnd_Remote_Max ){
+               k_ESteamNetConnectionEnd_Misc_InternalError ){
             network_client.retries = 40;
          }
          network_disconnect();
@@ -267,34 +332,44 @@ static void on_server_connect_status( CallbackMsg_t *msg ){
 }
 
 static void on_persona_state_change( CallbackMsg_t *msg ){
-   if( network_client.remote ){
-      PersonaStateChange_t *info = (void *)msg->m_pubParam;
+   if( !network_connected() )
+      return;
 
-      ISteamUser *hSteamUser = SteamAPI_SteamUser();
-   
-      vg_info( "User: %llu, change: %u\n", info->m_ulSteamID, 
-                                           info->m_nChangeFlags );
+   PersonaStateChange_t *info = (void *)msg->m_pubParam;
+   ISteamUser *hSteamUser = SteamAPI_SteamUser();
+
+   vg_info( "User: %llu, change: %u\n", info->m_ulSteamID, 
+                                        info->m_nChangeFlags );
 
-      if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
-         if( info->m_nChangeFlags & k_EPersonaChangeName ){
-            network_send_username();
+   if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
+      if( info->m_nChangeFlags & k_EPersonaChangeName ){
+         network_send_username();
+      }
+   }
+
+   if( info->m_nChangeFlags & k_EPersonaChangeRelationshipChanged ){
+      for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+         struct network_player *rp = &netplayers.list[i];
+         if( rp->steamid == info->m_ulSteamID ){
+            player_remote_update_friendflags( rp );
          }
       }
    }
 }
 
 static void network_connect(void){
+   char ip_buf[128];
+   vg_str str;
+   vg_strnull( &str, ip_buf, sizeof(ip_buf) );
+   vg_strcat( &str, network_client.server_adress );
+   vg_strcat( &str, ":" );
+   vg_strcati32( &str, NETWORK_PORT );
+
+   if( !vg_strgood(&str) ) return;
+
    /* Connect to server if not connected */
    SteamNetworkingIPAddr remoteAddr;
-
-#ifdef SR_USE_LOCALHOST
-   SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr, 27402 );
-#else
-   const char *server_lon1 = "46.101.34.155:27402";
-   SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lon1 );
-#endif
-   const char *server_lan = "192.168.1.32:27402";
-   SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lan );
+   SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, str.buffer );
 
    char buf[256];
    SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
@@ -304,38 +379,14 @@ static void network_connect(void){
                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 }
 
-static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
-   netmsg_scoreboard *sb = msg->m_pData;
+static void network_sign_on_complete(void){
+   vg_success( "Sign on completed\n" );
 
-   u32 base_size = sizeof(netmsg_scoreboard)-
-      sizeof(struct netmsg_board)*vg_list_size(track_infos),
-       expected = base_size+sizeof(struct netmsg_board)*sb->board_count;
-
-   if( msg->m_cbSize != expected ){
-      vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
-            msg->m_cbSize, expected );
-   }
-   else{
-      if( vg_list_size(track_infos) > sb->board_count )
-         vg_warn( "Server is out of date, not enough boards recieved\n");
-      else if( vg_list_size(track_infos) < sb->board_count )
-         vg_warn( "Client out of date, server sent more boards than we have\n");
-      else
-         vg_success( "Recieved new scoreboards from server\n" );
-
-      for( int i=0; i < vg_min(sb->board_count,vg_list_size(track_infos)); i++){
-         scoreboard_client_data.boards[i] = sb->boards[i];
-         highscores_board_printf( stdout, sb->boards[i].data, 10 );
-      }
+   /* send our init info */
+   network_send_username();
+   for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
+      network_send_item(i);
    }
-
-#if 0
-   /* We dont need to stay on the server currently */
-   SteamAPI_ISteamNetworkingSockets_CloseConnection(
-         hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
-#endif
-
-   network_scores_updated = 1;
 }
 
 static void poll_remote_connection(void){
@@ -363,6 +414,25 @@ static void poll_remote_connection(void){
          if( (tmp->inetmsg_id >= 200) && (tmp->inetmsg_id < 300) ){
             player_remote_rx_200_300( msg );
          }
+         else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
+            network_request_rx_300_400( msg );
+         }
+         else {
+            if( tmp->inetmsg_id == k_inetmsg_version ){
+               netmsg_version *version = msg->m_pData;
+               if( version->version != NETWORK_SKATERIFT_VERSION ){
+                  network_disconnect();
+                  /* we dont want to connect to this server ever */
+                  network_client.retries = 999;
+                  network_client.last_attempt = 999999999.9;
+                  vg_error( "version mismatch with server\n" );
+               }
+               else {
+                  network_client.remote_version = version->version;
+                  network_sign_on_complete();
+               }
+            }
+         }
 
          SteamAPI_SteamNetworkingMessage_t_Release( msg );
       }
@@ -409,15 +479,63 @@ static void network_update(void){
    }
 }
 
+static void chat_send_message( const char *message ){
+   if( !network_connected() ){
+      return;
+   }
+
+   netmsg_chat *chat = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
+   chat->inetmsg_id = k_inetmsg_chat;
+   chat->client = 0;
+
+   u32 l = vg_strncpy( message, chat->msg, NETWORK_MAX_CHAT, 
+                       k_strncpy_always_add_null );
+
+   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+         hSteamNetworkingSockets, network_client.remote, 
+         chat, sizeof(netmsg_chat)+l+1,
+         k_nSteamNetworkingSend_Reliable, NULL );
+}
+
+static int cmd_network_send_message( int argc, const char *argv[] ){
+   char buf[ NETWORK_MAX_CHAT ];
+   vg_str str;
+   vg_strnull( &str, buf, NETWORK_MAX_CHAT );
+
+   for( int i=0; i<argc; i ++ ){
+      vg_strcat( &str, argv[i] );
+
+      if( i < argc-1 )
+         vg_strcatch( &str, ' ' );
+   }
+
+   chat_send_message( buf );
+   return 0;
+}
+
 static void network_init(void){
    vg_console_reg_var( "network_info", &network_client.network_info,
                        k_var_dtype_i32, VG_VAR_PERSISTENT );
    if( steam_ready ){
+      u32 alloc_size = sizeof(struct network_request)*NETWORK_MAX_REQUESTS;
+      network_client.request_buffer = 
+         vg_linear_alloc( vg_mem.rtmemory, alloc_size );
+      memset( network_client.request_buffer, 0, alloc_size );
+
+      vg_pool *pool = &network_client.request_pool;
+      pool->buffer = network_client.request_buffer;
+      pool->count = NETWORK_MAX_REQUESTS;
+      pool->stride = sizeof( struct network_request );
+      pool->offset = offsetof( struct network_request, poolnode );
+      vg_pool_init( pool );
+
       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
                                on_server_connect_status );
       steam_register_callback( k_iPersonaStateChange, 
                                on_persona_state_change );
       request_auth_ticket();
+
+      vg_console_reg_cmd( "say", cmd_network_send_message, NULL );
    }
 }