-VG_STATIC void scores_update(void);
+#include "player.h"
+#include "network.h"
+#include "network_msg.h"
+#include "network_common.h"
+#include "player_remote.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;
+ }
+}
-VG_STATIC void on_auth_ticket_recieved( void *result, void *context ){
+static void on_auth_ticket_recieved( void *result, void *context ){
EncryptedAppTicketResponse_t *response = result;
if( response->m_eResult == k_EResultOK ){
}
}
-VG_STATIC void request_auth_ticket(void){
+static void request_auth_ticket(void){
/*
* TODO Check for one thats cached on the disk and load it.
* This might be OK though because steam seems to cache the result
SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
}
-VG_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 );
-}
-
-VG_STATIC void send_score_request(void){
+#if 0
+static void send_score_request(void){
vg_info( "Requesting scores\n" );
netmsg_scores_request req;
req.inetmsg_id = k_inetmsg_scores_request;
k_nSteamNetworkingSend_Reliable, NULL );
}
-VG_STATIC void send_score_update(void){
+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);
k_nSteamNetworkingSend_Reliable, NULL );
}
-VG_STATIC void send_nickname(void){
+static void send_nickname(void){
netmsg_set_nickname nick;
nick.inetmsg_id = k_inetmsg_set_nickname;
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 = 0xffffffff;
-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 );
}
-VG_STATIC void server_routine_update(void){
- if( network_client.name_update )
- send_nickname();
+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;
- send_score_update();
- send_score_request();
+ struct addon_cache *cache = &addon_system.cache[type];
+ vg_pool *pool = &cache->pool;
+
+ netmsg_playeritem *item =
+ alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
+ item->inetmsg_id = k_inetmsg_playeritem;
+ item->type = type;
+ item->client = 0;
+
+ SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+ addon_cache_entry *entry = vg_pool_item( pool, 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);
+
+ 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;
+ }
}
-VG_STATIC void on_server_connect_status( CallbackMsg_t *msg ){
+static void on_server_connect_status( CallbackMsg_t *msg ){
SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
vg_info( " Connection status changed for %lu\n", info->m_hConn );
vg_info( " %s -> %s\n",
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();
+ network_send_item( k_addon_type_board );
+ network_send_item( k_addon_type_player );
+ }
+ 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" );
}
}
-VG_STATIC void network_connect(void){
+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();
+ }
+ }
+ }
+}
+
+static void network_connect(void){
/* Connect to server if not connected */
SteamNetworkingIPAddr remoteAddr;
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 );
hSteamNetworkingSockets, &remoteAddr, 0, NULL );
}
-VG_STATIC void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
+static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
netmsg_scoreboard *sb = msg->m_pData;
u32 base_size = sizeof(netmsg_scoreboard)-
}
}
+#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;
}
-VG_STATIC void poll_remote_connection(void){
+static void poll_remote_connection(void){
SteamNetworkingMessage_t *messages[32];
int len;
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 );
+ }
SteamAPI_SteamNetworkingMessage_t_Release( msg );
}
}
}
-VG_STATIC void network_update(void){
+static void network_update(void){
if( !steam_ready )
return;
if( frame_delta > 0.1 ){
network_client.last_frame = vg.time_real;
- network_send_playerframe();
+ remote_player_send_playerframe();
}
+
+ remote_player_debug_update();
}
else {
if( (state == k_ESteamNetworkingConnectionState_Connecting) ||
}
}
-VG_STATIC void network_init(void){
+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 ){
steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack,
on_server_connect_status );
+ steam_register_callback( k_iPersonaStateChange,
+ on_persona_state_change );
request_auth_ticket();
}
}
-VG_STATIC void network_end(void){
+static void network_end(void){
/* TODO: Send buffered highscores that were not already */
if( (network_client.state == k_ESteamNetworkingConnectionState_Connected) ||
(network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff