3 #include "network_msg.h"
4 #include "network_common.h"
5 #include "player_remote.h"
8 #include "world_routes.h"
9 #include "vg/vg_imgui.h"
11 #include "ent_region.h"
13 static void scores_update(void);
15 static int packet_minsize( SteamNetworkingMessage_t
*msg
, u32 size
){
16 if( msg
->m_cbSize
< size
) {
17 vg_error( "Invalid packet size (must be at least %u)\n", size
);
25 static void on_auth_ticket_recieved( void *result
, void *context
){
26 EncryptedAppTicketResponse_t
*response
= result
;
28 if( response
->m_eResult
== k_EResultOK
){
29 vg_info( " New app ticket ready\n" );
32 vg_warn( " Could not request new encrypted app ticket (%u)\n",
33 response
->m_eResult
);
36 if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser
,
37 network_client
.app_symmetric_key
,
38 vg_list_size(network_client
.app_symmetric_key
),
39 &network_client
.app_key_length
)){
40 vg_success( " Loaded app ticket\n" );
43 vg_error( " No ticket availible\n" );
44 network_client
.app_key_length
= 0;
48 static void request_auth_ticket(void){
50 * TODO Check for one thats cached on the disk and load it.
51 * This might be OK though because steam seems to cache the result
54 vg_info( "Requesting new authorization ticket\n" );
56 vg_steam_async_call
*call
= vg_alloc_async_steam_api_call();
57 call
->userdata
= NULL
;
58 call
->p_handler
= on_auth_ticket_recieved
;
60 SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser
, NULL
, 0 );
63 static void network_send_username(void){
64 if( !network_connected() )
67 netmsg_playerusername
*update
= alloca( sizeof(netmsg_playerusername
)+
68 NETWORK_USERNAME_MAX
);
69 update
->inetmsg_id
= k_inetmsg_playerusername
;
72 ISteamFriends
*hSteamFriends
= SteamAPI_SteamFriends();
73 const char *username
= SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends
);
74 u32 chs
= str_utf8_collapse( username
, update
->name
, NETWORK_USERNAME_MAX
);
76 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
77 hSteamNetworkingSockets
, network_client
.remote
,
78 update
, sizeof(netmsg_playerusername
)+chs
+1,
79 k_nSteamNetworkingSend_Reliable
, NULL
);
82 static void network_send_region(void){
83 if( !network_connected() )
86 netmsg_region
*region
= alloca( sizeof(netmsg_region
) + NETWORK_REGION_MAX
);
88 region
->inetmsg_id
= k_inetmsg_region
;
90 region
->flags
= global_ent_region
.flags
;
92 u32 l
= vg_strncpy( global_ent_region
.location
, region
->loc
,
93 NETWORK_REGION_MAX
, k_strncpy_always_add_null
);
95 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
96 hSteamNetworkingSockets
, network_client
.remote
,
97 region
, sizeof(netmsg_region
)+l
+1,
98 k_nSteamNetworkingSend_Reliable
, NULL
);
101 static void network_send_request( netmsg_request
*req
, vg_msg
*body
,
103 netmsg_request
*res
, vg_msg
*body
,
109 vg_info( "Request scoreboard. Info (%u):\n", body
->cur
.co
);
110 vg_msg_print( body
, len
);
112 if( body
->error
!= k_vg_msg_error_OK
){
113 vg_error( "Body not OK\n" );
119 req
->id
= vg_pool_lru( &network_client
.request_pool
);
121 vg_pool_watch( &network_client
.request_pool
, req
->id
);
122 struct network_request
*pn
=
123 vg_pool_item( &network_client
.request_pool
, req
->id
);
124 pn
->callback
= callback
;
125 pn
->sendtime
= vg
.time_real
;
126 pn
->userdata
= userdata
;
129 vg_error( "Unable to send request. Pool is full.\n" );
136 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
137 hSteamNetworkingSockets
, network_client
.remote
,
138 req
, sizeof(netmsg_request
)+len
,
139 k_nSteamNetworkingSend_Reliable
, NULL
);
142 static void network_scoreboard_callback( netmsg_request
*res
, vg_msg
*body
,
144 world_instance
*world
= world_current_instance();
146 world_routes_recv_scoreboard( world
, body
, userdata
, res
->status
);
147 if( userdata
== world_sfd
.active_route_board
)
148 world_sfd_compile_active_scores();
153 /* mod_uid: world mod uid,
154 * route_uid: run name (just a string)
158 * 2 ALL TIME + CURRENT WEEK
160 * 10+ specific week index
162 static void network_request_scoreboard( const char *mod_uid
,
163 const char *route_uid
,
164 u32 week
, u64 userdata
){
165 if( !network_connected() )
168 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
169 req
->inetmsg_id
= k_inetmsg_request
;
172 vg_msg_init( &data
, req
->q
, 512 );
173 vg_msg_wkvstr( &data
, "endpoint", "scoreboard" );
174 vg_msg_wkvstr( &data
, "mod", mod_uid
);
175 vg_msg_wkvstr( &data
, "route", route_uid
);
176 vg_msg_wkvnum( &data
, "week", k_vg_msg_u32
, 1, &week
);
177 network_send_request( req
, &data
, network_scoreboard_callback
, userdata
);
180 static void network_publish_callback( netmsg_request
*res
, vg_msg
*body
,
182 if( res
->status
!= k_request_status_ok
){
183 vg_error( "Publish laptime, server error #%d\n", (i32
)res
->status
);
187 static void network_publish_laptime( const char *mod_uid
,
188 const char *route_uid
, f64 lap_time
){
189 if( !network_connected() )
192 i32 time_centiseconds
= lap_time
* 100.0;
194 netmsg_request
*req
= alloca( sizeof(netmsg_request
) + 512 );
195 req
->inetmsg_id
= k_inetmsg_request
;
198 vg_msg_init( &data
, req
->q
, 512 );
199 vg_msg_wkvstr( &data
, "endpoint", "setlap" );
200 vg_msg_wkvstr( &data
, "mod", mod_uid
);
201 vg_msg_wkvstr( &data
, "route", route_uid
);
202 vg_msg_wkvnum( &data
, "time", k_vg_msg_i32
, 1, &time_centiseconds
);
203 network_send_request( req
, &data
, network_publish_callback
, 0 );
206 static void network_request_rx_300_400( SteamNetworkingMessage_t
*msg
){
207 netmsg_blank
*tmp
= msg
->m_pData
;
209 if( tmp
->inetmsg_id
== k_inetmsg_request
){
212 else if( tmp
->inetmsg_id
== k_inetmsg_response
){
213 netmsg_request
*res
= (netmsg_request
*)msg
->m_pData
;
218 if( res
->status
== k_request_status_ok
){
219 vg_msg_init( &data
, res
->q
, msg
->m_cbSize
- sizeof(netmsg_request
) );
220 vg_success( "Response to #%d:\n", (i32
)res
->id
);
221 vg_msg_print( &data
, data
.max
);
225 vg_warn( "Server response to #%d: %d\n", (i32
)res
->id
, res
->status
);
229 struct network_request
*pn
=
230 vg_pool_item( &network_client
.request_pool
, res
->id
);
231 pn
->callback( res
, body
, pn
->userdata
);
232 vg_pool_unwatch( &network_client
.request_pool
, res
->id
);
237 static void network_send_item( enum netmsg_playeritem_type type
){
238 if( !network_connected() )
241 netmsg_playeritem
*item
=
242 alloca( sizeof(netmsg_playeritem
) + ADDON_UID_MAX
);
243 item
->inetmsg_id
= k_inetmsg_playeritem
;
244 item
->type_index
= type
;
247 if( (type
== k_netmsg_playeritem_world0
) ||
248 (type
== k_netmsg_playeritem_world1
) ){
250 enum world_purpose purpose
= type
- k_netmsg_playeritem_world0
;
251 addon_reg
*reg
= world_static
.instance_addons
[ purpose
];
254 addon_alias_uid( ®
->alias
, item
->uid
);
260 enum addon_type addon_type
= k_addon_type_none
;
261 if( type
== k_netmsg_playeritem_board
){
262 view_id
= localplayer
.board_view_slot
;
263 addon_type
= k_addon_type_board
;
265 else if( type
== k_netmsg_playeritem_player
){
266 view_id
= localplayer
.playermodel_view_slot
;
267 addon_type
= k_addon_type_player
;
270 struct addon_cache
*cache
= &addon_system
.cache
[addon_type
];
271 vg_pool
*pool
= &cache
->pool
;
273 SDL_AtomicLock( &addon_system
.sl_cache_using_resources
);
274 addon_cache_entry
*entry
= vg_pool_item( pool
, view_id
);
275 addon_alias_uid( &entry
->reg_ptr
->alias
, item
->uid
);
276 SDL_AtomicUnlock( &addon_system
.sl_cache_using_resources
);
279 vg_info( "send equip: [%u] %s\n",
280 item
->type_index
, item
->uid
);
281 u32 chs
= strlen(item
->uid
);
283 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
284 hSteamNetworkingSockets
, network_client
.remote
,
285 item
, sizeof(netmsg_playeritem
)+chs
+1,
286 k_nSteamNetworkingSend_Reliable
, NULL
);
289 static void network_disconnect(void){
290 SteamAPI_ISteamNetworkingSockets_CloseConnection(
291 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 0 );
292 network_client
.remote
= 0;
293 network_client
.state
= k_ESteamNetworkingConnectionState_None
;
295 for( int i
=0; i
<vg_list_size(netplayers
.list
); i
++ ){
296 netplayers
.list
[i
].active
= 0;
300 static void network_status_string( vg_str
*str
, u32
*colour
){
301 if( skaterift
.demo_mode
){
302 vg_strcat( str
, "Offline" );
307 if( network_client
.user_intent
== k_server_intent_offline
){
308 vg_strcat( str
, "Offline" );
311 ESteamNetworkingConnectionState state
= network_client
.state
;
313 if( state
== k_ESteamNetworkingConnectionState_None
)
314 vg_strcat( str
, "No Connection" );
315 else if( state
== k_ESteamNetworkingConnectionState_Connecting
){
316 vg_strcat( str
, "Connecting to:\nskaterift.com" );
318 if( network_client
.retries
){
319 vg_strcat( str
, "\n(" );
320 vg_strcati32( str
, network_client
.retries
);
321 vg_strcat( str
, " retries)" );
324 else if( state
== k_ESteamNetworkingConnectionState_Connected
){
325 vg_strcat( str
, "Connected to:\nskaterift.com" );
326 *colour
= 0xff00a020;
328 else if( state
== k_ESteamNetworkingConnectionState_ClosedByPeer
)
329 vg_strcat( str
, "Connection Closed" );
330 else if( state
== k_ESteamNetworkingConnectionState_FindingRoute
)
331 vg_strcat( str
, "Finding Route" );
333 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
){
334 vg_strcat( str
, "Problem Detected\nLocally" );
335 *colour
= 0xff0000a0;
338 vg_strcat( str
, "???" );
342 vg_strcat( str
, "Steam Offline" );
343 *colour
= 0xff0000a0;
347 static void render_server_status_gui(void){
348 render_fb_bind( gpipeline
.fb_workshop_preview
, 0 );
352 vg_ui
.cur_indice
= 0;
353 vg_ui
.vert_start
= 0;
354 vg_ui
.indice_start
= 0;
356 ui_rect r
= { 0, 0, 128, 48 };
360 vg_strnull( &str
, buf
, sizeof(buf
) );
363 network_status_string( &str
, &bg
);
366 ui_text( r
, buf
, 1, k_ui_align_center
, 0 );
367 ui_flush( k_ui_shader_colour
, 128, 48 );
369 skaterift
.rt_textures
[ k_skaterift_rt_server_status
] =
370 gpipeline
.fb_workshop_preview
->attachments
[0].id
;
373 static void on_server_connect_status( CallbackMsg_t
*msg
){
374 SteamNetConnectionStatusChangedCallback_t
*info
= (void *)msg
->m_pubParam
;
375 vg_info( " Connection status changed for %lu\n", info
->m_hConn
);
376 vg_info( " %s -> %s\n",
377 string_ESteamNetworkingConnectionState(info
->m_eOldState
),
378 string_ESteamNetworkingConnectionState(info
->m_info
.m_eState
) );
380 if( info
->m_hConn
== network_client
.remote
){
381 network_client
.state
= info
->m_info
.m_eState
;
383 if( info
->m_info
.m_eState
==
384 k_ESteamNetworkingConnectionState_Connected
){
385 vg_success(" Connected to remote server.. authenticating\n");
387 /* send version info to server */
388 netmsg_version version
;
389 version
.inetmsg_id
= k_inetmsg_version
;
390 version
.version
= NETWORK_SKATERIFT_VERSION
;
391 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
392 hSteamNetworkingSockets
, network_client
.remote
, &version
,
393 sizeof(netmsg_version
), k_nSteamNetworkingSend_Reliable
, NULL
);
395 /* TODO: We should really wait to see if the server is in auth mode
397 u32 size
= sizeof(netmsg_auth
) + network_client
.app_key_length
;
398 netmsg_auth
*auth
= alloca(size
);
399 auth
->inetmsg_id
= k_inetmsg_auth
;
400 auth
->ticket_length
= network_client
.app_key_length
;
401 for( int i
=0; i
<network_client
.app_key_length
; i
++ )
402 auth
->ticket
[i
] = network_client
.app_symmetric_key
[i
];
404 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
405 hSteamNetworkingSockets
, network_client
.remote
, auth
, size
,
406 k_nSteamNetworkingSend_Reliable
, NULL
);
408 else if( info
->m_info
.m_eState
==
409 k_ESteamNetworkingConnectionState_ClosedByPeer
){
411 if( info
->m_info
.m_eEndReason
==
412 k_ESteamNetConnectionEnd_Misc_InternalError
){
413 network_client
.retries
= 40;
415 network_disconnect();
417 else if( info
->m_info
.m_eState
==
418 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
){
419 network_disconnect();
423 //vg_warn( " Recieved signal from unknown connection\n" );
426 render_server_status_gui();
429 static void on_persona_state_change( CallbackMsg_t
*msg
){
430 if( !network_connected() )
433 PersonaStateChange_t
*info
= (void *)msg
->m_pubParam
;
434 ISteamUser
*hSteamUser
= SteamAPI_SteamUser();
436 vg_info( "User: %llu, change: %u\n", info
->m_ulSteamID
,
437 info
->m_nChangeFlags
);
439 if( info
->m_ulSteamID
== SteamAPI_ISteamUser_GetSteamID(hSteamUser
) ){
440 if( info
->m_nChangeFlags
& k_EPersonaChangeName
){
441 network_send_username();
445 if( info
->m_nChangeFlags
& k_EPersonaChangeRelationshipChanged
){
446 for( u32 i
=0; i
<NETWORK_MAX_PLAYERS
; i
++ ){
447 struct network_player
*rp
= &netplayers
.list
[i
];
448 if( rp
->steamid
== info
->m_ulSteamID
){
449 player_remote_update_friendflags( rp
);
455 static void network_connect(void){
458 vg_strnull( &str
, ip_buf
, sizeof(ip_buf
) );
459 vg_strcat( &str
, network_client
.server_adress
);
460 vg_strcat( &str
, ":" );
461 vg_strcati32( &str
, NETWORK_PORT
);
463 if( !vg_strgood(&str
) ) return;
465 /* Connect to server if not connected */
466 SteamNetworkingIPAddr remoteAddr
;
467 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, str
.buffer
);
470 SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr
, buf
, 256, 1 );
471 vg_info( "connect to: %s\n", buf
);
473 network_client
.remote
= SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
474 hSteamNetworkingSockets
, &remoteAddr
, 0, NULL
);
477 static void network_sign_on_complete(void){
478 vg_success( "Sign on completed\n" );
480 /* send our init info */
481 network_send_username();
482 for( u32 i
=0; i
<k_netmsg_playeritem_max
; i
++ ){
483 network_send_item(i
);
485 network_send_region();
488 static void poll_remote_connection(void){
489 SteamNetworkingMessage_t
*messages
[32];
492 for( int i
=0; i
<10; i
++ ){
493 len
= SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
494 hSteamNetworkingSockets
, network_client
.remote
,
495 messages
, vg_list_size(messages
));
500 for( int i
=0; i
<len
; i
++ ){
501 SteamNetworkingMessage_t
*msg
= messages
[i
];
503 if( msg
->m_cbSize
< sizeof(netmsg_blank
) ){
504 vg_warn( "Discarding message (too small: %d)\n", msg
->m_cbSize
);
508 netmsg_blank
*tmp
= msg
->m_pData
;
510 if( (tmp
->inetmsg_id
>= 200) && (tmp
->inetmsg_id
< 300) ){
511 player_remote_rx_200_300( msg
);
513 else if( (tmp
->inetmsg_id
>= 300) && (tmp
->inetmsg_id
< 400) ){
514 network_request_rx_300_400( msg
);
517 if( tmp
->inetmsg_id
== k_inetmsg_version
){
518 netmsg_version
*version
= msg
->m_pData
;
519 if( version
->version
!= NETWORK_SKATERIFT_VERSION
){
520 network_disconnect();
521 /* we dont want to connect to this server ever */
522 network_client
.retries
= 999;
523 network_client
.last_attempt
= 999999999.9;
524 vg_error( "version mismatch with server\n" );
527 network_client
.remote_version
= version
->version
;
528 network_sign_on_complete();
533 SteamAPI_SteamNetworkingMessage_t_Release( msg
);
538 static void network_update(void){
542 ESteamNetworkingConnectionState state
= network_client
.state
;
544 if( network_client
.user_intent
== k_server_intent_offline
){
545 if( state
!= k_ESteamNetworkingConnectionState_None
)
546 network_disconnect();
551 if( state
== k_ESteamNetworkingConnectionState_Connected
){
552 poll_remote_connection();
553 f64 frame_delta
= vg
.time_real
- network_client
.last_frame
;
555 if( frame_delta
> NETWORK_FRAMERATE
){
556 network_client
.last_frame
= vg
.time_real
;
557 remote_player_send_playerframe();
558 localplayer
.sfx_buffer_count
= 0;
561 remote_player_debug_update();
564 if( (state
== k_ESteamNetworkingConnectionState_Connecting
) ||
565 (state
== k_ESteamNetworkingConnectionState_FindingRoute
) ){
569 f64 waited
= vg
.time_real
- network_client
.last_attempt
,
572 if( network_client
.retries
> 5 )
575 if( waited
< min_wait
)
579 network_client
.retries
++;
580 network_client
.last_attempt
= vg
.time_real
;
585 static void chat_send_message( const char *message
){
586 if( !network_connected() ){
590 netmsg_chat
*chat
= alloca( sizeof(netmsg_chat
) + NETWORK_MAX_CHAT
);
591 chat
->inetmsg_id
= k_inetmsg_chat
;
594 u32 l
= vg_strncpy( message
, chat
->msg
, NETWORK_MAX_CHAT
,
595 k_strncpy_always_add_null
);
597 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
598 hSteamNetworkingSockets
, network_client
.remote
,
599 chat
, sizeof(netmsg_chat
)+l
+1,
600 k_nSteamNetworkingSend_Reliable
, NULL
);
603 static int cmd_network_send_message( int argc
, const char *argv
[] ){
604 char buf
[ NETWORK_MAX_CHAT
];
606 vg_strnull( &str
, buf
, NETWORK_MAX_CHAT
);
608 for( int i
=0; i
<argc
; i
++ ){
609 vg_strcat( &str
, argv
[i
] );
612 vg_strcatch( &str
, ' ' );
615 chat_send_message( buf
);
619 static void network_init(void){
620 vg_console_reg_var( "network_info", &network_client
.network_info
,
621 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
623 u32 alloc_size
= sizeof(struct network_request
)*NETWORK_MAX_REQUESTS
;
624 network_client
.request_buffer
=
625 vg_linear_alloc( vg_mem
.rtmemory
, alloc_size
);
626 memset( network_client
.request_buffer
, 0, alloc_size
);
628 vg_pool
*pool
= &network_client
.request_pool
;
629 pool
->buffer
= network_client
.request_buffer
;
630 pool
->count
= NETWORK_MAX_REQUESTS
;
631 pool
->stride
= sizeof( struct network_request
);
632 pool
->offset
= offsetof( struct network_request
, poolnode
);
633 vg_pool_init( pool
);
635 steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack
,
636 on_server_connect_status
);
637 steam_register_callback( k_iPersonaStateChange
,
638 on_persona_state_change
);
639 request_auth_ticket();
641 vg_console_reg_cmd( "say", cmd_network_send_message
, NULL
);
645 static void network_end(void){
646 /* TODO: Send buffered highscores that were not already */
647 if( (network_client
.state
== k_ESteamNetworkingConnectionState_Connected
) ||
648 (network_client
.state
== k_ESteamNetworkingConnectionState_Connecting
) )
650 SteamAPI_ISteamNetworkingSockets_CloseConnection(
651 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );