network.h

   1 /*
   2  * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
   3  * All trademarks are property of their respective owners
   4  */
   5
   6 #ifndef NETWORK_H
   7 #define NETWORK_H
   8
   9 #include "vg/vg_stdint.h"
  10 #include "steam.h"
  11 #include "network_msg.h"
  12 #include "highscores.h"
  13
  14 VG_STATIC int network_scores_updated = 0;
  15
  16 /*
  17  * Interface
  18  */
  19 //#define SR_USE_LOCALHOST
  20
  21 /* Call it at start; Connects us to the gameserver */
  22 VG_STATIC void network_init(void);
  23
  24 /* Run this from main loop */
  25 VG_STATIC void network_update(void);
  26
  27 /* Call it at shutdown */
  28 VG_STATIC void network_end(void);
  29
  30 /*
  31  * Can buffer up a bunch of these by calling many times, they will be
  32  * sent at the next connection
  33  */
  34 VG_STATIC void network_submit_highscore( u32 trackid, u16 points, u16 time );
  35
  36 /*
  37  * Game endpoints are provided with the same names to allow running without a
  38  * network connection.
  39  */
  40 #ifdef SR_NETWORKED
  41
  42 /*
  43  * Runtime connection stuff
  44  */
  45 VG_STATIC u8 steam_app_ticket[ 1024 ];
  46 VG_STATIC u32 steam_app_ticket_length;
  47 VG_STATIC int network_name_update = 1;
  48
  49 VG_STATIC HSteamNetConnection cremote;
  50 VG_STATIC ESteamNetworkingConnectionState cremote_state =
  51      k_ESteamNetworkingConnectionState_None;
  52
  53 /*
  54  * Implementation
  55  */
  56
  57 VG_STATIC void scores_update(void);
  58
  59 VG_STATIC void on_auth_ticket_recieved( void *result, void *context )
  60 {
  61    EncryptedAppTicketResponse_t *response = result;
  62
  63    if( response->m_eResult == k_EResultOK )
  64    {
  65       vg_info( "  New app ticket ready\n" );
  66    }
  67    else
  68    {
  69       vg_warn( "  Could not request new encrypted app ticket (%u)\n",
  70                   response->m_eResult );
  71    }
  72
  73    if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
  74             steam_app_ticket,
  75             vg_list_size(steam_app_ticket),
  76             &steam_app_ticket_length ))
  77    {
  78       vg_success( "  Loaded app ticket (%u bytes)\n", steam_app_ticket_length );
  79    }
  80    else
  81    {
  82       vg_error( "  No ticket availible\n" );
  83       steam_app_ticket_length = 0;
  84    }
  85 }
  86
  87 VG_STATIC void request_auth_ticket(void)
  88 {
  89    /*
  90     * TODO Check for one thats cached on the disk and load it.
  91     * This might be OK though because steam seems to cache the result
  92     */
  93
  94    vg_info( "Requesting new authorization ticket\n" );
  95    steam_async *call = steam_new_async();
  96    call->data = NULL;
  97    call->p_handler = on_auth_ticket_recieved;
  98    call->id =  SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser,
  99                                                               NULL, 0 );
 100 }
 101
 102 VG_STATIC void send_auth_ticket(void)
 103 {
 104    u32 size = sizeof(netmsg_auth) + steam_app_ticket_length;
 105    netmsg_auth *auth = alloca(size);
 106
 107    auth->inetmsg_id = k_inetmsg_auth;
 108    auth->ticket_length = steam_app_ticket_length;
 109    for( int i=0; i<steam_app_ticket_length; i++ )
 110       auth->ticket[i] = steam_app_ticket[i];
 111
 112    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 113          hSteamNetworkingSockets, cremote, auth, size,
 114          k_nSteamNetworkingSend_Reliable, NULL );
 115 }
 116
 117 VG_STATIC void send_score_request(void)
 118 {
 119    vg_info( "Requesting scores\n" );
 120    netmsg_scores_request req;
 121    req.inetmsg_id = k_inetmsg_scores_request;
 122
 123    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 124          hSteamNetworkingSockets, cremote, &req, sizeof(netmsg_scores_request),
 125          k_nSteamNetworkingSend_Reliable, NULL );
 126 }
 127
 128 VG_STATIC void send_score_update(void)
 129 {
 130    vg_info( "Sending scores\n" );
 131    u32 size = sizeof(netmsg_set_score) +
 132                   vg_list_size(track_infos)*sizeof(struct netmsg_score_record);
 133    netmsg_set_score *setscore = alloca( size );
 134    setscore->inetmsg_id = k_inetmsg_set_score;
 135
 136    int count = 0;
 137    for( u32 i=0; i<vg_list_size(track_infos); i++ )
 138    {
 139       if( track_infos[i].push )
 140       {
 141          track_infos[i].push = 0;
 142          highscore_record *user_record = highscore_find_user_record( 0, i );
 143
 144          if( !user_record )
 145          {
 146             vg_error( "No score set but tried to upload for track %u\n", i );
 147             continue;
 148          }
 149
 150          setscore->records[count].trackid = i;
 151          setscore->records[count].playerid = 0;
 152          setscore->records[count].points = user_record->points;
 153          setscore->records[count].time = user_record->time;
 154
 155          count ++;
 156       }
 157    }
 158
 159    if( count == 0 )
 160       return;
 161
 162    u32 send_size = sizeof(netmsg_set_score) +
 163                   count*sizeof(struct netmsg_score_record);
 164    setscore->record_count = count;
 165
 166    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 167          hSteamNetworkingSockets, cremote, setscore, send_size,
 168          k_nSteamNetworkingSend_Reliable, NULL );
 169 }
 170
 171 VG_STATIC void send_nickname(void)
 172 {
 173    netmsg_set_nickname nick;
 174    nick.inetmsg_id = k_inetmsg_set_nickname;
 175
 176    memset( nick.nickname, 0, 16 );
 177    vg_strncpy( steam_username_at_startup, nick.nickname, 16,
 178                k_strncpy_allow_cutoff );
 179
 180    SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
 181          hSteamNetworkingSockets, cremote, &nick, sizeof(netmsg_set_nickname),
 182          k_nSteamNetworkingSend_Reliable, NULL );
 183
 184    network_name_update = 0;
 185 }
 186
 187 VG_STATIC void server_routine_update(void)
 188 {
 189    send_auth_ticket();
 190
 191    if( network_name_update )
 192       send_nickname();
 193
 194    send_score_update();
 195    send_score_request();
 196 }
 197
 198 VG_STATIC void on_server_connect_status( CallbackMsg_t *msg )
 199 {
 200    SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
 201    vg_info( "  Connection status changed for %lu\n", info->m_hConn );
 202    vg_info( "  %s -> %s\n",
 203          string_ESteamNetworkingConnectionState(info->m_eOldState),
 204          string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
 205
 206    if( info->m_hConn == cremote )
 207    {
 208       cremote_state = info->m_info.m_eState;
 209       if( info->m_info.m_eState ==
 210             k_ESteamNetworkingConnectionState_Connected )
 211       {
 212          vg_success("  Connected to remote server.. running updates\n");
 213          server_routine_update();
 214       }
 215    }
 216    else
 217    {
 218       vg_warn( "  Recieved signal from unknown connection\n" );
 219    }
 220 }
 221
 222 VG_STATIC void network_connect_gc(void)
 223 {
 224    /* Connect to server if not connected */
 225    SteamNetworkingIPAddr remoteAddr;
 226
 227 #ifdef SR_USE_LOCALHOST
 228    SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr, 27402 );
 229 #else
 230    const char *server_lon1 = "46.101.34.155:27402";
 231    SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lon1 );
 232 #endif
 233
 234    char buf[256];
 235    SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
 236    vg_info( "connect to: %s\n", buf );
 237
 238    cremote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
 239                   hSteamNetworkingSockets, &remoteAddr, 0, NULL );
 240 }
 241
 242 VG_STATIC void on_inet_scoreboard( SteamNetworkingMessage_t *msg )
 243 {
 244    netmsg_scoreboard *sb = msg->m_pData;
 245
 246    u32 base_size = sizeof(netmsg_scoreboard)-
 247       sizeof(struct netmsg_board)*vg_list_size(track_infos),
 248        expected = base_size+sizeof(struct netmsg_board)*sb->board_count;
 249
 250    if( msg->m_cbSize != expected )
 251    {
 252       vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
 253             msg->m_cbSize, expected );
 254    }
 255    else
 256    {
 257       if( vg_list_size(track_infos) > sb->board_count )
 258          vg_warn( "Server is out of date, not enough boards recieved\n");
 259       else if( vg_list_size(track_infos) < sb->board_count )
 260          vg_warn( "Client out of date, server sent more boards than we have\n");
 261       else
 262          vg_success( "Recieved new scoreboards from server\n" );
 263
 264       for( int i=0; i < vg_min(sb->board_count,vg_list_size(track_infos)); i++)
 265       {
 266          scoreboard_client_data.boards[i] = sb->boards[i];
 267          highscores_board_printf( stdout, sb->boards[i].data, 10 );
 268       }
 269    }
 270
 271    /* We dont need to stay on the server currently */
 272    SteamAPI_ISteamNetworkingSockets_CloseConnection(
 273          hSteamNetworkingSockets, cremote, 0, NULL, 1 );
 274
 275    network_scores_updated = 1;
 276 }
 277
 278 VG_STATIC void poll_connection(void)
 279 {
 280    SteamNetworkingMessage_t *messages[32];
 281    int len;
 282
 283    while(1)
 284    {
 285       len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
 286             hSteamNetworkingSockets, cremote, messages, vg_list_size(messages));
 287
 288       if( len <= 0 )
 289          return;
 290
 291       for( int i=0; i<len; i++ )
 292       {
 293          SteamNetworkingMessage_t *msg = messages[i];
 294
 295          if( msg->m_cbSize < sizeof(netmsg_blank) )
 296          {
 297             vg_warn( "Discarding message (too small: %d)\n", msg->m_cbSize );
 298             continue;
 299          }
 300
 301          netmsg_blank *tmp = msg->m_pData;
 302
 303          if( tmp->inetmsg_id == k_inetmsg_scoreboard )
 304             on_inet_scoreboard( msg );
 305
 306          SteamAPI_SteamNetworkingMessage_t_Release( msg );
 307       }
 308    }
 309 }
 310
 311 /*
 312  * Subroutine to be connected to main game loop, runs all routines on timers
 313  */
 314 VG_STATIC void network_update(void)
 315 {
 316    if( steam_ready )
 317    {
 318       static double last_update = 0.0;
 319       poll_connection();
 320
 321       if( vg.time > (last_update + 60.0) )
 322       {
 323          last_update = vg.time;
 324
 325          if( steam_app_ticket_length )
 326          {
 327             network_connect_gc();
 328          }
 329          else
 330          {
 331             vg_low( "Not making remote connection; app ticket not gotten\n" );
 332          }
 333       }
 334
 335       if( vg.time > (last_update + 10.0) &&
 336             (cremote_state == k_ESteamNetworkingConnectionState_Connected ))
 337       {
 338          vg_warn( "Connected to server but no return... disconnecting\n" );
 339          SteamAPI_ISteamNetworkingSockets_CloseConnection(
 340                hSteamNetworkingSockets, cremote, 0, NULL, 1 );
 341       }
 342    }
 343 }
 344
 345 VG_STATIC void network_init(void)
 346 {
 347    if( steam_ready )
 348    {
 349       steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
 350                                on_server_connect_status );
 351       request_auth_ticket();
 352    }
 353 }
 354
 355 VG_STATIC void network_end(void)
 356 {
 357    /* TODO: Fire off any buffered highscores that need to be setn */
 358    if( cremote_state == k_ESteamNetworkingConnectionState_Connected ||
 359        cremote_state == k_ESteamNetworkingConnectionState_Connecting )
 360    {
 361       SteamAPI_ISteamNetworkingSockets_CloseConnection(
 362             hSteamNetworkingSockets, cremote, 0, NULL, 1 );
 363    }
 364 }
 365
 366 #else /* SR_NETWORKED */
 367
 368 VG_STATIC void network_init(void){}
 369 VG_STATIC void network_update(void){}
 370 VG_STATIC void network_end(void){}
 371
 372 #endif /* SR_NETWORKED */
 373 #endif /* NETWORK_H */