3 #include "network_msg.h"
4 #include "network_common.h"
5 #include "player_remote.h"
8 #include "world_routes.h"
10 static void scores_update(void);
12 static int packet_minsize( SteamNetworkingMessage_t
*msg
, u32 size
){
13 if( msg
->m_cbSize
< size
) {
14 vg_error( "Invalid packet size (must be at least %u)\n", size
);
22 static void on_auth_ticket_recieved( void *result
, void *context
){
23 EncryptedAppTicketResponse_t
*response
= result
;
25 if( response
->m_eResult
== k_EResultOK
){
26 vg_info( " New app ticket ready\n" );
29 vg_warn( " Could not request new encrypted app ticket (%u)\n",
30 response
->m_eResult
);
33 if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser
,
34 network_client
.app_symmetric_key
,
35 vg_list_size(network_client
.app_symmetric_key
),
36 &network_client
.app_key_length
)){
37 vg_success( " Loaded app ticket\n" );
40 vg_error( " No ticket availible\n" );
41 network_client
.app_key_length
= 0;
45 static void request_auth_ticket(void){
47 * TODO Check for one thats cached on the disk and load it.
48 * This might be OK though because steam seems to cache the result
51 vg_info( "Requesting new authorization ticket\n" );
53 vg_steam_async_call
*call
= vg_alloc_async_steam_api_call();
54 call
->userdata
= NULL
;
55 call
->p_handler
= on_auth_ticket_recieved
;
57 SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser
, NULL
, 0 );
60 static void network_send_username(void){
61 netmsg_playerusername
*update
= alloca( sizeof(netmsg_playerusername
)+
62 NETWORK_USERNAME_MAX
);
63 update
->inetmsg_id
= k_inetmsg_playerusername
;
66 ISteamFriends
*hSteamFriends
= SteamAPI_SteamFriends();
67 const char *username
= SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends
);
68 u32 chs
= str_utf8_collapse( username
, update
->name
, NETWORK_USERNAME_MAX
);
70 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
71 hSteamNetworkingSockets
, network_client
.remote
,
72 update
, sizeof(netmsg_playerusername
)+chs
+1,
73 k_nSteamNetworkingSend_Reliable
, NULL
);
76 static void network_send_request( netmsg_request
*req
, vg_msg
*body
,
78 netmsg_request
*res
, vg_msg
*body
,
84 vg_info( "Request scoreboard. Info (%u):\n", body
->cur
.co
);
85 vg_msg_print( body
, len
);
87 if( body
->error
!= k_vg_msg_error_OK
){
88 vg_error( "Body not OK\n" );
94 req
->id
= vg_pool_lru( &network_client
.request_pool
);
96 vg_pool_watch( &network_client
.request_pool
, req
->id
);
97 struct network_request
*pn
=
98 vg_pool_item( &network_client
.request_pool
, req
->id
);
99 pn
->callback
= callback
;
100 pn
->sendtime
= vg
.time_real
;
101 pn
->userdata
= userdata
;
104 vg_error( "Unable to send request. Pool is full.\n" );
111 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
112 hSteamNetworkingSockets
, network_client
.remote
,
113 req
, sizeof(netmsg_request
)+len
,
114 k_nSteamNetworkingSend_Reliable
, NULL
);
117 static void network_scoreboard_callback( netmsg_request
*res
, vg_msg
*body
,
119 world_instance
*world
= world_current_instance();
121 world_routes_recv_scoreboard( world
, body
, userdata
, res
->status
);
122 if( userdata
== world_sfd
.active_route_board
)
123 world_sfd_compile_active_scores();
128 /* mod_uid: world mod uid,
129 * route_uid: run name (just a string)
133 * 2 ALL TIME + CURRENT WEEK
135 * 10+ specific week index
137 static void network_request_scoreboard( const char *mod_uid
,
138 const char *route_uid
,
139 u32 week
, u64 userdata
){
140 if( !network_connected() )
143 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
144 req
->inetmsg_id
= k_inetmsg_request
;
147 vg_msg_init( &data
, req
->q
, 512 );
148 vg_msg_wkvstr( &data
, "endpoint", "scoreboard" );
149 vg_msg_wkvstr( &data
, "mod", mod_uid
);
150 vg_msg_wkvstr( &data
, "route", route_uid
);
151 vg_msg_wkvu32( &data
, "week", week
);
152 network_send_request( req
, &data
, network_scoreboard_callback
, userdata
);
155 static void network_publish_callback( netmsg_request
*res
, vg_msg
*body
,
157 if( res
->status
!= k_request_status_ok
){
158 vg_error( "Publish laptime, server error #%d\n", (i32
)res
->status
);
162 static void network_publish_laptime( const char *mod_uid
,
163 const char *route_uid
, f64 lap_time
){
164 if( !network_connected() )
167 i32 time_centiseconds
= lap_time
* 100.0;
169 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
170 req
->inetmsg_id
= k_inetmsg_request
;
173 vg_msg_init( &data
, req
->q
, 512 );
174 vg_msg_wkvstr( &data
, "endpoint", "setlap" );
175 vg_msg_wkvstr( &data
, "mod", mod_uid
);
176 vg_msg_wkvstr( &data
, "route", route_uid
);
177 vg_msg_wkvi32( &data
, "time", time_centiseconds
);
178 network_send_request( req
, &data
, network_publish_callback
, 0 );
181 static void network_request_rx_300_400( SteamNetworkingMessage_t
*msg
){
182 netmsg_blank
*tmp
= msg
->m_pData
;
184 if( tmp
->inetmsg_id
== k_inetmsg_request
){
187 else if( tmp
->inetmsg_id
== k_inetmsg_response
){
188 netmsg_request
*res
= (netmsg_request
*)msg
->m_pData
;
193 if( res
->status
== k_request_status_ok
){
194 vg_msg_init( &data
, res
->q
, msg
->m_cbSize
- sizeof(netmsg_request
) );
195 vg_success( "Response to #%d:\n", (i32
)res
->id
);
196 vg_msg_print( &data
, data
.max
);
200 vg_warn( "Server response to #%d: %d\n", (i32
)res
->id
, res
->status
);
204 struct network_request
*pn
=
205 vg_pool_item( &network_client
.request_pool
, res
->id
);
206 pn
->callback( res
, body
, pn
->userdata
);
207 vg_pool_unwatch( &network_client
.request_pool
, res
->id
);
212 static void network_send_item( enum netmsg_playeritem_type type
){
213 if( !network_connected() )
216 netmsg_playeritem
*item
=
217 alloca( sizeof(netmsg_playeritem
) + ADDON_UID_MAX
);
218 item
->inetmsg_id
= k_inetmsg_playeritem
;
219 item
->type_index
= type
;
222 if( (type
== k_netmsg_playeritem_world0
) ||
223 (type
== k_netmsg_playeritem_world1
) ){
225 enum world_purpose purpose
= type
- k_netmsg_playeritem_world0
;
226 addon_reg
*reg
= world_static
.instance_addons
[ purpose
];
229 addon_alias_uid( ®
->alias
, item
->uid
);
235 enum addon_type addon_type
= k_addon_type_none
;
236 if( type
== k_netmsg_playeritem_board
){
237 view_id
= localplayer
.board_view_slot
;
238 addon_type
= k_addon_type_board
;
240 else if( type
== k_netmsg_playeritem_player
){
241 view_id
= localplayer
.playermodel_view_slot
;
242 addon_type
= k_addon_type_player
;
247 struct addon_cache
*cache
= &addon_system
.cache
[addon_type
];
248 vg_pool
*pool
= &cache
->pool
;
250 SDL_AtomicLock( &addon_system
.sl_cache_using_resources
);
251 addon_cache_entry
*entry
= vg_pool_item( pool
, view_id
);
252 addon_alias_uid( &entry
->reg_ptr
->alias
, item
->uid
);
253 SDL_AtomicUnlock( &addon_system
.sl_cache_using_resources
);
256 vg_info( "send equip: [%u] %s\n",
257 item
->type_index
, item
->uid
);
258 u32 chs
= strlen(item
->uid
);
260 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
261 hSteamNetworkingSockets
, network_client
.remote
,
262 item
, sizeof(netmsg_playeritem
)+chs
+1,
263 k_nSteamNetworkingSend_Reliable
, NULL
);
266 static void network_disconnect(void){
267 SteamAPI_ISteamNetworkingSockets_CloseConnection(
268 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 0 );
269 network_client
.remote
= 0;
271 for( int i
=0; i
<vg_list_size(netplayers
.list
); i
++ ){
272 netplayers
.list
[i
].active
= 0;
276 static void on_server_connect_status( CallbackMsg_t
*msg
){
277 SteamNetConnectionStatusChangedCallback_t
*info
= (void *)msg
->m_pubParam
;
278 vg_info( " Connection status changed for %lu\n", info
->m_hConn
);
279 vg_info( " %s -> %s\n",
280 string_ESteamNetworkingConnectionState(info
->m_eOldState
),
281 string_ESteamNetworkingConnectionState(info
->m_info
.m_eState
) );
283 if( info
->m_hConn
== network_client
.remote
){
284 network_client
.state
= info
->m_info
.m_eState
;
286 if( info
->m_info
.m_eState
==
287 k_ESteamNetworkingConnectionState_Connected
){
288 vg_success(" Connected to remote server.. authenticating\n");
290 /* TODO: We should really wait to see if the server is in auth mode
292 u32 size
= sizeof(netmsg_auth
) + network_client
.app_key_length
;
293 netmsg_auth
*auth
= alloca(size
);
294 auth
->inetmsg_id
= k_inetmsg_auth
;
295 auth
->ticket_length
= network_client
.app_key_length
;
296 for( int i
=0; i
<network_client
.app_key_length
; i
++ )
297 auth
->ticket
[i
] = network_client
.app_symmetric_key
[i
];
299 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
300 hSteamNetworkingSockets
, network_client
.remote
, auth
, size
,
301 k_nSteamNetworkingSend_Reliable
, NULL
);
303 network_send_username();
305 for( u32 i
=0; i
<k_netmsg_playeritem_max
; i
++ ){
306 network_send_item(i
);
309 else if( info
->m_info
.m_eState
==
310 k_ESteamNetworkingConnectionState_ClosedByPeer
){
312 if( info
->m_info
.m_eEndReason
==
313 k_ESteamNetConnectionEnd_Remote_Max
){
314 network_client
.retries
= 40;
316 network_disconnect();
318 else if( info
->m_info
.m_eState
==
319 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
){
320 network_disconnect();
324 //vg_warn( " Recieved signal from unknown connection\n" );
328 static void on_persona_state_change( CallbackMsg_t
*msg
){
329 if( !network_connected() )
332 PersonaStateChange_t
*info
= (void *)msg
->m_pubParam
;
333 ISteamUser
*hSteamUser
= SteamAPI_SteamUser();
335 vg_info( "User: %llu, change: %u\n", info
->m_ulSteamID
,
336 info
->m_nChangeFlags
);
338 if( info
->m_ulSteamID
== SteamAPI_ISteamUser_GetSteamID(hSteamUser
) ){
339 if( info
->m_nChangeFlags
& k_EPersonaChangeName
){
340 network_send_username();
344 if( info
->m_nChangeFlags
& k_EPersonaChangeRelationshipChanged
){
345 for( u32 i
=0; i
<NETWORK_MAX_PLAYERS
; i
++ ){
346 struct network_player
*rp
= &netplayers
.list
[i
];
347 if( rp
->steamid
== info
->m_ulSteamID
){
348 player_remote_update_friendflags( rp
);
354 static void network_connect(void){
357 vg_strnull( &str
, ip_buf
, sizeof(ip_buf
) );
358 vg_strcat( &str
, network_client
.server_adress
);
359 vg_strcat( &str
, ":" );
360 vg_strcati32( &str
, NETWORK_PORT
);
362 if( !vg_strgood(&str
) ) return;
364 /* Connect to server if not connected */
365 SteamNetworkingIPAddr remoteAddr
;
366 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, str
.buffer
);
369 SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr
, buf
, 256, 1 );
370 vg_info( "connect to: %s\n", buf
);
372 network_client
.remote
= SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
373 hSteamNetworkingSockets
, &remoteAddr
, 0, NULL
);
376 static void poll_remote_connection(void){
377 SteamNetworkingMessage_t
*messages
[32];
380 for( int i
=0; i
<10; i
++ ){
381 len
= SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
382 hSteamNetworkingSockets
, network_client
.remote
,
383 messages
, vg_list_size(messages
));
388 for( int i
=0; i
<len
; i
++ ){
389 SteamNetworkingMessage_t
*msg
= messages
[i
];
391 if( msg
->m_cbSize
< sizeof(netmsg_blank
) ){
392 vg_warn( "Discarding message (too small: %d)\n", msg
->m_cbSize
);
396 netmsg_blank
*tmp
= msg
->m_pData
;
398 if( (tmp
->inetmsg_id
>= 200) && (tmp
->inetmsg_id
< 300) ){
399 player_remote_rx_200_300( msg
);
401 else if( (tmp
->inetmsg_id
>= 300) && (tmp
->inetmsg_id
< 400) ){
402 network_request_rx_300_400( msg
);
405 SteamAPI_SteamNetworkingMessage_t_Release( msg
);
410 static void network_update(void){
414 ESteamNetworkingConnectionState state
= network_client
.state
;
416 if( state
== k_ESteamNetworkingConnectionState_Connected
){
417 poll_remote_connection();
418 f64 frame_delta
= vg
.time_real
- network_client
.last_frame
;
420 if( frame_delta
> NETWORK_FRAMERATE
){
421 network_client
.last_frame
= vg
.time_real
;
422 remote_player_send_playerframe();
423 player__clear_sfx_buffer();
426 remote_player_debug_update();
429 if( (state
== k_ESteamNetworkingConnectionState_Connecting
) ||
430 (state
== k_ESteamNetworkingConnectionState_FindingRoute
) ){
434 f64 waited
= vg
.time_real
- network_client
.last_attempt
,
437 if( network_client
.retries
> 5 )
440 if( waited
< min_wait
)
444 network_client
.retries
++;
445 network_client
.last_attempt
= vg
.time_real
;
450 static void network_init(void){
451 vg_console_reg_var( "network_info", &network_client
.network_info
,
452 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
454 u32 alloc_size
= sizeof(struct network_request
)*NETWORK_MAX_REQUESTS
;
455 network_client
.request_buffer
=
456 vg_linear_alloc( vg_mem
.rtmemory
, alloc_size
);
457 memset( network_client
.request_buffer
, 0, alloc_size
);
459 vg_pool
*pool
= &network_client
.request_pool
;
460 pool
->buffer
= network_client
.request_buffer
;
461 pool
->count
= NETWORK_MAX_REQUESTS
;
462 pool
->stride
= sizeof( struct network_request
);
463 pool
->offset
= offsetof( struct network_request
, poolnode
);
464 vg_pool_init( pool
);
466 steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack
,
467 on_server_connect_status
);
468 steam_register_callback( k_iPersonaStateChange
,
469 on_persona_state_change
);
470 request_auth_ticket();
474 static void network_end(void){
475 /* TODO: Send buffered highscores that were not already */
476 if( (network_client
.state
== k_ESteamNetworkingConnectionState_Connected
) ||
477 (network_client
.state
== k_ESteamNetworkingConnectionState_Connecting
) )
479 SteamAPI_ISteamNetworkingSockets_CloseConnection(
480 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );