X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=network.c;h=74e03bf720187fe7dc2cd85393ba0dd0d01a82f4;hb=be5e25dee2c54c2a22ca3bbb5bbe0eb6149343be;hp=786250605d56d0d78e378c32bbf62c5fd98c950f;hpb=509214f72c8974bb30091799752412419dd59632;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/network.c b/network.c
index 7862506..74e03bf 100644
--- a/network.c
+++ b/network.c
@@ -1,3 +1,8 @@
+#include "skaterift.h"
+#include "vg/vg_steam.h"
+#include "vg/vg_steam_networking.h"
+#include "vg/vg_steam_auth.h"
+#include "vg/vg_steam_friends.h"
 #include "player.h"
 #include "network.h"
 #include "network_msg.h"
@@ -6,10 +11,21 @@
 #include "world.h"
 #include "world_sfd.h"
 #include "world_routes.h"
+#include "vg/vg_imgui.h"
+#include "gui.h"
+#include "ent_region.h"
+
+struct network_client network_client =
+{
+   .auth_mode = eServerModeAuthentication,
+   .state = k_ESteamNetworkingConnectionState_None,
+   .server_adress = "46.101.34.155",
+   .last_intent_change = -99999.9
+};
 
 static void scores_update(void);
 
-static int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
+int packet_minsize( SteamNetworkingMessage_t *msg, u32 size ){
    if( msg->m_cbSize < size ) {
       vg_error( "Invalid packet size (must be at least %u)\n", size );
       return 0;
@@ -58,6 +74,9 @@ static void request_auth_ticket(void){
 }
 
 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;
@@ -73,6 +92,26 @@ static void network_send_username(void){
          k_nSteamNetworkingSend_Reliable, NULL );
 }
 
+void network_send_region(void)
+{
+   if( !network_connected() )
+      return;
+   
+   netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+
+   region->inetmsg_id = k_inetmsg_region;
+   region->client = 0;
+   region->flags = global_ent_region.flags;
+
+   u32 l = vg_strncpy( global_ent_region.location, region->loc, 
+                       NETWORK_REGION_MAX, k_strncpy_always_add_null );
+
+   SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+         hSteamNetworkingSockets, network_client.remote, 
+         region, sizeof(netmsg_region)+l+1,
+         k_nSteamNetworkingSend_Reliable, NULL );
+}
+
 static void network_send_request( netmsg_request *req, vg_msg *body,
                                   void (*callback)( 
                                      netmsg_request *res, vg_msg *body, 
@@ -134,9 +173,9 @@ static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
  *   .
  *   10+ specific week index
  */
-static void network_request_scoreboard( const char *mod_uid, 
-                                        const char *route_uid,
-                                        u32 week, u64 userdata ){
+void network_request_scoreboard( const char *mod_uid, 
+                                 const char *route_uid,
+                                 u32 week, u64 userdata ){
    if( !network_connected() ) 
       return;
 
@@ -148,7 +187,7 @@ static void network_request_scoreboard( const char *mod_uid,
    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 );
+   vg_msg_wkvnum( &data, "week", k_vg_msg_u32, 1, &week );
    network_send_request( req, &data, network_scoreboard_callback, userdata );
 }
 
@@ -159,8 +198,8 @@ static void network_publish_callback( netmsg_request *res, vg_msg *body,
    }
 }
 
-static void network_publish_laptime( const char *mod_uid, 
-                                     const char *route_uid, f64 lap_time ){
+void network_publish_laptime( const char *mod_uid, 
+                              const char *route_uid, f64 lap_time ){
    if( !network_connected() )
       return;
 
@@ -174,7 +213,7 @@ static void network_publish_laptime( const char *mod_uid,
    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 );
+   vg_msg_wkvnum( &data, "time", k_vg_msg_i32, 1, &time_centiseconds );
    network_send_request( req, &data, network_publish_callback, 0 );
 }
 
@@ -209,7 +248,8 @@ static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
    }
 }
 
-static void network_send_item( enum netmsg_playeritem_type type ){
+void network_send_item( enum netmsg_playeritem_type type )
+{
    if( !network_connected() )
       return;
 
@@ -241,8 +281,6 @@ static void network_send_item( enum netmsg_playeritem_type type ){
          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;
@@ -267,12 +305,88 @@ 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;
    }
 }
 
+void network_status_string( vg_str *str, u32 *colour )
+{
+   if( skaterift.demo_mode ){
+      vg_strcat( str, "Offline" );
+      return;
+   }
+
+   if( steam_ready ){
+      if( network_client.user_intent == k_server_intent_offline ){
+         vg_strcat( str, "Offline" );
+      }
+      else {
+         ESteamNetworkingConnectionState state = network_client.state;
+
+         if( state == k_ESteamNetworkingConnectionState_None )
+            vg_strcat( str, "No Connection" );
+         else if( state == k_ESteamNetworkingConnectionState_Connecting ){
+            vg_strcat( str, "Connecting to:\nskaterift.com" );
+
+            if( network_client.retries ){
+               vg_strcat( str, "\n(" );
+               vg_strcati32( str, network_client.retries );
+               vg_strcat( str, " retries)" );
+            }
+         }
+         else if( state == k_ESteamNetworkingConnectionState_Connected ){
+            vg_strcat( str, "Connected to:\nskaterift.com" );
+            *colour = 0xff00a020;
+         }
+         else if( state == k_ESteamNetworkingConnectionState_ClosedByPeer )
+            vg_strcat( str, "Connection Closed" );
+         else if( state == k_ESteamNetworkingConnectionState_FindingRoute )
+            vg_strcat( str, "Finding Route" );
+         else if( state ==
+               k_ESteamNetworkingConnectionState_ProblemDetectedLocally){
+            vg_strcat( str, "Problem Detected\nLocally" );
+            *colour = 0xff0000a0;
+         }
+         else
+            vg_strcat( str, "???" );
+      }
+   }
+   else {
+      vg_strcat( str, "Steam Offline" );
+      *colour = 0xff0000a0;
+   }
+}
+
+void render_server_status_gui(void)
+{
+   render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+
+   /* HACK */
+	vg_ui.cur_vert = 0;
+	vg_ui.cur_indice = 0;
+   vg_ui.vert_start = 0;
+   vg_ui.indice_start = 0;
+
+   ui_rect r = { 0, 0, 128, 48 };
+   
+   char buf[128];
+   vg_str str;
+   vg_strnull( &str, buf, sizeof(buf) );
+
+   u32 bg = 0xff000000;
+   network_status_string( &str, &bg );
+
+   ui_fill( r, bg );
+   ui_text( r, buf, 1, k_ui_align_center, 0 );
+   ui_flush( k_ui_shader_colour, 128, 48 );
+   
+   skaterift.rt_textures[ k_skaterift_rt_server_status ] =
+      gpipeline.fb_workshop_preview->attachments[0].id;
+}
+
 static void on_server_connect_status( CallbackMsg_t *msg ){
    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
@@ -287,6 +401,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;
@@ -299,18 +421,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();
@@ -323,6 +439,8 @@ static void on_server_connect_status( CallbackMsg_t *msg ){
    else{
       //vg_warn( "  Recieved signal from unknown connection\n" );
    }
+
+   render_server_status_gui();
 }
 
 static void on_persona_state_change( CallbackMsg_t *msg ){
@@ -340,6 +458,15 @@ static void on_persona_state_change( CallbackMsg_t *msg ){
          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){
@@ -364,6 +491,17 @@ static void network_connect(void){
                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 }
 
+static void network_sign_on_complete(void){
+   vg_success( "Sign on completed\n" );
+
+   /* send our init info */
+   network_send_username();
+   for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
+      network_send_item(i);
+   }
+   network_send_region();
+}
+
 static void poll_remote_connection(void){
    SteamNetworkingMessage_t *messages[32];
    int len;
@@ -392,18 +530,42 @@ static void poll_remote_connection(void){
          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 );
       }
    }
 }
 
-static void network_update(void){
+void network_update(void)
+{
    if( !steam_ready )
       return;
 
    ESteamNetworkingConnectionState state = network_client.state;
 
+   if( network_client.user_intent == k_server_intent_offline ){
+      if( state != k_ESteamNetworkingConnectionState_None )
+         network_disconnect();
+
+      return;
+   }
+
    if( state == k_ESteamNetworkingConnectionState_Connected ){
       poll_remote_connection();
       f64 frame_delta = vg.time_real - network_client.last_frame;
@@ -411,7 +573,7 @@ static void network_update(void){
       if( frame_delta > NETWORK_FRAMERATE ){
          network_client.last_frame = vg.time_real;
          remote_player_send_playerframe();
-         player__clear_sfx_buffer();
+         localplayer.sfx_buffer_count = 0;
       }
 
       remote_player_debug_update();
@@ -438,7 +600,43 @@ static void network_update(void){
    }
 }
 
-static void network_init(void){
+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;
+}
+
+void network_init(void)
+{
    vg_console_reg_var( "network_info", &network_client.network_info,
                        k_var_dtype_i32, VG_VAR_PERSISTENT );
    if( steam_ready ){
@@ -459,10 +657,13 @@ static void network_init(void){
       steam_register_callback( k_iPersonaStateChange, 
                                on_persona_state_change );
       request_auth_ticket();
+
+      vg_console_reg_cmd( "say", cmd_network_send_message, NULL );
    }
 }
 
-static void network_end(void){
+void network_end(void)
+{
    /* TODO: Send buffered highscores that were not already */
    if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
        (network_client.state == k_ESteamNetworkingConnectionState_Connecting) )