X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;ds=sidebyside;f=network.c;h=d60dc0cb38f429e32d102163e737649e2154e561;hb=a7d144c7905105909cc4434e0ab43008bbb8f89f;hp=53ebd4bc0bf63ed0e17dfae9e21f806db0e3f411;hpb=825c3bce18272c0f81659e0eac469709d0462836;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/network.c b/network.c index 53ebd4b..d60dc0c 100644 --- a/network.c +++ b/network.c @@ -3,6 +3,7 @@ #include "network_msg.h" #include "network_common.h" #include "player_remote.h" +#include "world_sfd.h" static void scores_update(void); @@ -135,7 +136,7 @@ static void network_send_username(void){ netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+ NETWORK_USERNAME_MAX ); update->inetmsg_id = k_inetmsg_playerusername; - update->index = 0xffffffff; + update->index = 0xff; ISteamFriends *hSteamFriends = SteamAPI_SteamFriends(); const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends); @@ -147,6 +148,189 @@ static void network_send_username(void){ 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->len; + vg_info( "Request scoreboard. Info (%u):\n", body->len ); + vg_msg_print( body ); + + 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; + } + + /* TODO: frame pointers?? */ + + u32 l = 0; + vg_msg rows = *body; + if( vg_msg_seekframe( &rows, "rows", k_vg_msg_first ) ){ + vg_msg entry = rows; + + while( vg_msg_seekframe( &entry, NULL, k_vg_msg_next ) ){ + const char *username = vg_msg_seekkvstr( &entry, "username", + k_vg_msg_first ); + sfd_encode( l ++, username ); + vg_msg_skip_frame( &entry ); + } + } +} + +/* 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; + req->id = 0; /* TODO: pool allocatable */ + + vg_msg data = {0}; + data.buf = req->q; + data.max = 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_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 = {0}; + + if( res->status == k_request_status_ok ){ + data.buf = res->q; + data.len = msg->m_cbSize - sizeof(netmsg_request); + data.max = data.len; + vg_success( "Response to #%d:\n", (i32)res->id ); + vg_msg_print( &data ); + 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) ){ + + addon_reg *reg = world_static.addon_hub; + + if( type == k_netmsg_playeritem_world1 ) + reg = world_static.addon_client; + + if( reg ) + addon_alias_uid( ®->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 ); +} + static void network_disconnect(void){ SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 ); @@ -185,6 +369,10 @@ static void on_server_connect_status( CallbackMsg_t *msg ){ k_nSteamNetworkingSend_Reliable, NULL ); network_send_username(); + + for( u32 i=0; im_info.m_eState == k_ESteamNetworkingConnectionState_ClosedByPeer ){ @@ -302,6 +490,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 ); } @@ -318,9 +509,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(); @@ -351,6 +543,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,