X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=network.c;h=b0ae67786542032c53b3ee7872d7e5357bdb9654;hb=7e1fe6c7931ba4492aa10ac5eebc316b74fb5dac;hp=3235c697e84ee7359a9d9a3bd4c739fdd082d2a6;hpb=333430b27b5f9f73cbe9ad7921a4735aaff444f1;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/network.c b/network.c
index 3235c69..b0ae677 100644
--- a/network.c
+++ b/network.c
@@ -1,7 +1,9 @@
 #include "player.h"
 #include "network.h"
 #include "network_msg.h"
+#include "network_common.h"
 #include "player_remote.h"
+#include "world_sfd.h"
 
 static void scores_update(void);
 
@@ -131,18 +133,218 @@ static void server_routine_update(void){
 #endif
 
 static void network_send_username(void){
-   netmsg_playerusername update;
-   memset( &update, 0, sizeof(update) );
-   update.inetmsg_id = k_inetmsg_playerusername;
-   update.index = 0xffffffff;
+   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);
-   str_utf8_collapse( username, update.username, sizeof(update.username) );
+   u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
 
    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
          hSteamNetworkingSockets, network_client.remote, 
-         &update, sizeof(update),
+         update, sizeof(netmsg_playerusername)+chs+1,
+         k_nSteamNetworkingSend_Reliable, NULL );
+}
+
+static void network_send_request( netmsg_request *req, vg_msg *body,
+                                  void (*callback)( netmsg_request *res, 
+                                                    vg_msg *body )){
+   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( 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;
+      }
+      else{
+         vg_error( "Unable to send request. Pool is full.\n" );
+         return;
+      }
+   }
+   else
+      req->id = 0;
+
+   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+         hSteamNetworkingSockets, network_client.remote, 
+         req, sizeof(netmsg_request)+len,
+         k_nSteamNetworkingSend_Reliable, NULL );
+}
+
+static void network_scoreboard_callback( netmsg_request *res, vg_msg *body ){
+   for( u32 i=0; i<13; i++ )
+      sfd_encode( i, "" );
+
+   if( res->status != k_request_status_ok ){
+      char buf[32];
+      vg_str s;
+      vg_strnull( &s, buf, 32 );
+      vg_strcat( &s, "Error: " );
+      vg_strcati32( &s, res->status );
+
+      sfd_encode( 4, buf );
+      return;
+   }
+
+   u32 l = 0;
+   if( vg_msg_seekframe( body, "rows" ) ){
+      while( vg_msg_seekframe( body, NULL ) ){
+         const char *username = vg_msg_getkvstr( body, "username" );
+
+         if( username )
+            sfd_encode( l ++, username );
+         else
+            sfd_encode( l ++, "UNKNOWN USER" );
+
+         vg_msg_skip_frame( body );
+      }
+   }
+}
+
+/* mod_uid: world mod uid,
+ * route_uid: run name (just a string)
+ * week: 0 for all-time, n for week #
+ */
+static void network_request_scoreboard( const char *mod_uid, 
+                                        const char *route_uid,
+                                        u32 week ){
+   if( !network_client.remote )
+      return;
+
+   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 );
+}
+
+static void network_publish_callback( netmsg_request *res, vg_msg *body ){
+   if( res->status != k_request_status_ok ){
+      vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
+   }
+}
+
+static void network_publish_laptime( const char *mod_uid, 
+                                     const char *route_uid, f64 lap_time ){
+   if( !network_client.remote )
+      return;
+
+   i32 time_centiseconds = lap_time * 100.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", "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 );
+}
+
+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 );
+         vg_pool_unwatch( &network_client.request_pool, res->id );
+      }
+   }
+}
+
+static void network_send_item( enum netmsg_playeritem_type type ){
+   if( !network_client.remote )
+      return;
+
+   netmsg_playeritem *item = 
+      alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
+   item->inetmsg_id = k_inetmsg_playeritem;
+   item->type_index = type;
+   item->client = 0;
+
+   if( (type == k_netmsg_playeritem_world0) ||
+       (type == k_netmsg_playeritem_world1) ){
+
+      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 );
+      else 
+         item->uid[0] = '\0';
+   }
+   else{
+      u16 view_id = 0;
+      enum addon_type addon_type = k_addon_type_none;
+      if( type == k_netmsg_playeritem_board ){
+         view_id = localplayer.board_view_slot;
+         addon_type = k_addon_type_board;
+      }
+      else if( type == k_netmsg_playeritem_player ){
+         view_id = localplayer.playermodel_view_slot;
+         addon_type = k_addon_type_player;
+      }
+      else 
+         assert(0);
+
+      struct addon_cache *cache = &addon_system.cache[addon_type];
+      vg_pool *pool = &cache->pool;
+
+      SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+      addon_cache_entry *entry = vg_pool_item( pool, view_id );
+      addon_alias_uid( &entry->reg_ptr->alias, item->uid );
+      SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+   }
+
+   vg_info( "send equip: [%u] %s\n", 
+            item->type_index, item->uid );
+   u32 chs = strlen(item->uid);
+
+   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+         hSteamNetworkingSockets, network_client.remote, 
+         item, sizeof(netmsg_playeritem)+chs+1,
          k_nSteamNetworkingSend_Reliable, NULL );
 }
 
@@ -184,6 +386,10 @@ static void on_server_connect_status( CallbackMsg_t *msg ){
                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 ){
@@ -301,6 +507,9 @@ 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 );
+         }
 
          SteamAPI_SteamNetworkingMessage_t_Release( msg );
       }
@@ -317,9 +526,10 @@ static void network_update(void){
       poll_remote_connection();
       f64 frame_delta = vg.time_real - network_client.last_frame;
 
-      if( frame_delta > 0.1 ){
+      if( frame_delta > NETWORK_FRAMERATE ){
          network_client.last_frame = vg.time_real;
          remote_player_send_playerframe();
+         player__clear_sfx_buffer();
       }
 
       remote_player_debug_update();
@@ -350,6 +560,18 @@ 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,