#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);
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; i<vg_list_size(track_infos); i++ ){
- if( track_infos[i].push ){
- track_infos[i].push = 0;
-
-#if 0
- highscore_record *user_record = highscore_find_user_record( 0, i );
-
- if( !user_record ){
- vg_error( "No score set but tried to upload for track %u\n", i );
- continue;
- }
-#endif
- highscore_record *user_record = &track_infos[i].record;
-
- setscore->records[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();
+
+ world_routes_recv_scoreboard( world, body, userdata, res->status );
+ if( userdata == world_sfd.active_route_board )
+ world_sfd_compile_active_scores();
+}
+
- 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 );
- network_client.name_update = 0;
+/* 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_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, userdata );
}
-#endif
-#if 0
-static void server_routine_update(void){
- send_score_update();
- send_score_request();
+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 );
+ }
}
-#endif
-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;
+static void network_publish_laptime( const char *mod_uid,
+ const char *route_uid, f64 lap_time ){
+ if( !network_client.remote )
+ return;
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
- u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
+ i32 time_centiseconds = lap_time * 100.0;
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
- update, sizeof(netmsg_playerusername)+chs+1,
- k_nSteamNetworkingSend_Reliable, NULL );
+ 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 );
}
-static void network_send_item( enum addon_type type ){
- if( network_client.remote ){
- u16 id = 0;
- if( type == k_addon_type_board )
- id = localplayer.board_view_slot;
- else if( type == k_addon_type_player )
- id = localplayer.playermodel_view_slot;
+static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
+ netmsg_blank *tmp = msg->m_pData;
- struct addon_cache *cache = &addon_system.cache[type];
- vg_pool *pool = &cache->pool;
+ 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 );
+ }
+ }
+}
- netmsg_playeritem *item =
- alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
- item->inetmsg_id = k_inetmsg_playeritem;
- item->type = type;
- item->client = 0;
+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( ®->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, id );
+ 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, item->uid );
-
- u32 chs = strlen(item->uid);
+ 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 );
- }
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, network_client.remote,
+ item, sizeof(netmsg_playeritem)+chs+1,
+ k_nSteamNetworkingSend_Reliable, NULL );
}
static void network_disconnect(void){
k_nSteamNetworkingSend_Reliable, NULL );
network_send_username();
- network_send_item( k_addon_type_board );
- network_send_item( k_addon_type_player );
+
+ for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
+ network_send_item(i);
+ }
}
else if( info->m_info.m_eState ==
k_ESteamNetworkingConnectionState_ClosedByPeer ){
static void network_connect(void){
/* 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,
+ network_client.server_adress );
char buf[256];
SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
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;
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 );
}
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();
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,
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff