X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=network.c;h=786250605d56d0d78e378c32bbf62c5fd98c950f;hb=137d40d96fe923600d8378b8e138e3c276f27ff4;hp=a35ead4ef3a6004403c9c78d139ef345f426e127;hpb=71aba6c4108d99f39379f54b04bb71a6d2dc09b5;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/network.c b/network.c index a35ead4..7862506 100644 --- a/network.c +++ b/network.c @@ -1,7 +1,11 @@ #include "player.h" #include "network.h" #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); @@ -53,107 +57,209 @@ 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){ + 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; irecords[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; + + netmsg_request *req = alloca( sizeof(netmsg_request) + 512 ); + req->inetmsg_id = k_inetmsg_request; - network_client.name_update = 0; + 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 -static void network_send_playerframe(void){ - netmsg_playerframe frame; - frame.inetmsg_id = k_inetmsg_playerframe; - v3_copy( localplayer.rb.co, frame.pos_temp ); +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 ); + } +} - SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( - hSteamNetworkingSockets, network_client.remote, - &frame, sizeof(frame), - k_nSteamNetworkingSend_Unreliable, NULL ); +static void network_publish_laptime( const char *mod_uid, + const char *route_uid, f64 lap_time ){ + if( !network_connected() ) + 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, 0 ); } -#if 0 -static void server_routine_update(void){ - send_score_update(); - send_score_request(); +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 ); + } + } } -#endif -static void network_send_username(void){ - netmsg_playerusername update; - memset( &update, 0, sizeof(update) ); - update.inetmsg_id = k_inetmsg_playerusername; - update.index = 0xffffffff; +static void network_send_item( enum netmsg_playeritem_type type ){ + if( !network_connected() ) + return; - ISteamFriends *hSteamFriends = SteamAPI_SteamFriends(); - const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends); - str_utf8_collapse( username, update.username, sizeof(update.username) ); + 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( ®->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, - &update, sizeof(update), + item, sizeof(netmsg_playeritem)+chs+1, k_nSteamNetworkingSend_Reliable, NULL ); } @@ -195,6 +301,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 ){ @@ -216,30 +326,35 @@ 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(); - if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){ - if( info->m_nChangeFlags == k_EPersonaChangeNickname ){ - network_send_username(); - } + 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(); } } } 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 ); @@ -249,40 +364,6 @@ static void network_connect(void){ hSteamNetworkingSockets, &remoteAddr, 0, NULL ); } -static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){ - netmsg_scoreboard *sb = msg->m_pData; - - 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 ); - } - } - -#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){ SteamNetworkingMessage_t *messages[32]; int len; @@ -308,6 +389,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 ); } @@ -324,10 +408,13 @@ 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; - network_send_playerframe(); + remote_player_send_playerframe(); + player__clear_sfx_buffer(); } + + remote_player_debug_update(); } else { if( (state == k_ESteamNetworkingConnectionState_Connecting) || @@ -355,6 +442,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,