#include "player.h"
#include "network.h"
+#include "network_msg.h"
+#include "network_common.h"
+#include "player_remote.h"
+#include "world_sfd.h"
static void scores_update(void);
+static 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;
+ }
+ else{
+ return 1;
+ }
+}
+
static void on_auth_ticket_recieved( void *result, void *context ){
EncryptedAppTicketResponse_t *response = result;
SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
}
-static void send_auth_ticket(void){
- u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
- netmsg_auth *auth = alloca(size);
-
- auth->inetmsg_id = k_inetmsg_auth;
- auth->ticket_length = network_client.app_key_length;
- for( int i=0; i<network_client.app_key_length; i++ )
- auth->ticket[i] = network_client.app_symmetric_key[i];
-
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote, auth, size,
- k_nSteamNetworkingSend_Reliable, NULL );
-}
-
+#if 0
static void send_score_request(void){
vg_info( "Requesting scores\n" );
netmsg_scores_request req;
network_client.name_update = 0;
}
+#endif
+
+#if 0
+static void server_routine_update(void){
+ send_score_update();
+ send_score_request();
+}
+#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 = 0xff;
-static void network_send_playerframe(void){
- netmsg_playerframe frame;
- frame.inetmsg_id = k_inetmsg_playerframe;
- v3_copy( localplayer.rb.co, frame.pos_temp );
+ 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,
- &frame, sizeof(frame),
- k_nSteamNetworkingSend_Unreliable, NULL );
+ update, sizeof(netmsg_playerusername)+chs+1,
+ k_nSteamNetworkingSend_Reliable, NULL );
}
-static void server_routine_update(void){
- if( network_client.name_update )
- send_nickname();
+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;
+ }
+ }
- send_score_update();
- send_score_request();
+ 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 );
+ network_client.remote = 0;
+
+ for( int i=0; i<vg_list_size(netplayers.list); i++ ){
+ netplayers.list[i].active = 0;
+ }
}
static void on_server_connect_status( CallbackMsg_t *msg ){
if( info->m_hConn == network_client.remote ){
network_client.state = info->m_info.m_eState;
- if( info->m_info.m_eState == k_ESteamNetworkingConnectionState_Connected ){
+
+ if( info->m_info.m_eState ==
+ k_ESteamNetworkingConnectionState_Connected ){
vg_success(" Connected to remote server.. authenticating\n");
- send_auth_ticket();
+
+ /* 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;
+ netmsg_auth *auth = alloca(size);
+ auth->inetmsg_id = k_inetmsg_auth;
+ auth->ticket_length = network_client.app_key_length;
+ for( int i=0; i<network_client.app_key_length; i++ )
+ auth->ticket[i] = network_client.app_symmetric_key[i];
+
+ 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 ){
+ network_client.retries = 40;
+ }
+ network_disconnect();
+ }
+ else if( info->m_info.m_eState ==
+ k_ESteamNetworkingConnectionState_ProblemDetectedLocally ){
+ network_disconnect();
}
}
else{
- vg_warn( " Recieved signal from unknown connection\n" );
+ //vg_warn( " Recieved signal from unknown connection\n" );
+ }
+}
+
+static void on_persona_state_change( CallbackMsg_t *msg ){
+ if( network_client.remote ){
+ 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();
+ }
+ }
}
}
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 );
char buf[256];
SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
}
}
+#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;
}
netmsg_blank *tmp = msg->m_pData;
- if( tmp->inetmsg_id == k_inetmsg_scoreboard )
- on_inet_scoreboard( msg );
+ 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;
- network_send_playerframe();
+ remote_player_send_playerframe();
+ player__clear_sfx_buffer();
}
+
+ remote_player_debug_update();
}
else {
if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
}
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,
+ on_persona_state_change );
request_auth_ticket();
}
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff