3 #include "network_msg.h"
4 #include "network_common.h"
5 #include "player_remote.h"
7 static void scores_update(void);
9 static int packet_minsize( SteamNetworkingMessage_t
*msg
, u32 size
){
10 if( msg
->m_cbSize
< size
) {
11 vg_error( "Invalid packet size (must be at least %u)\n", size
);
19 static void on_auth_ticket_recieved( void *result
, void *context
){
20 EncryptedAppTicketResponse_t
*response
= result
;
22 if( response
->m_eResult
== k_EResultOK
){
23 vg_info( " New app ticket ready\n" );
26 vg_warn( " Could not request new encrypted app ticket (%u)\n",
27 response
->m_eResult
);
30 if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser
,
31 network_client
.app_symmetric_key
,
32 vg_list_size(network_client
.app_symmetric_key
),
33 &network_client
.app_key_length
)){
34 vg_success( " Loaded app ticket\n" );
37 vg_error( " No ticket availible\n" );
38 network_client
.app_key_length
= 0;
42 static void request_auth_ticket(void){
44 * TODO Check for one thats cached on the disk and load it.
45 * This might be OK though because steam seems to cache the result
48 vg_info( "Requesting new authorization ticket\n" );
50 vg_steam_async_call
*call
= vg_alloc_async_steam_api_call();
51 call
->userdata
= NULL
;
52 call
->p_handler
= on_auth_ticket_recieved
;
54 SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser
, NULL
, 0 );
58 static void send_score_request(void){
59 vg_info( "Requesting scores\n" );
60 netmsg_scores_request req
;
61 req
.inetmsg_id
= k_inetmsg_scores_request
;
63 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
64 hSteamNetworkingSockets
, network_client
.remote
,
65 &req
, sizeof(netmsg_scores_request
),
66 k_nSteamNetworkingSend_Reliable
, NULL
);
69 static void send_score_update(void){
70 vg_info( "Sending scores\n" );
71 u32 size
= sizeof(netmsg_set_score
) +
72 vg_list_size(track_infos
)*sizeof(struct netmsg_score_record
);
73 netmsg_set_score
*setscore
= alloca( size
);
74 setscore
->inetmsg_id
= k_inetmsg_set_score
;
77 for( u32 i
=0; i
<vg_list_size(track_infos
); i
++ ){
78 if( track_infos
[i
].push
){
79 track_infos
[i
].push
= 0;
82 highscore_record
*user_record
= highscore_find_user_record( 0, i
);
85 vg_error( "No score set but tried to upload for track %u\n", i
);
89 highscore_record
*user_record
= &track_infos
[i
].record
;
91 setscore
->records
[count
].trackid
= i
;
92 setscore
->records
[count
].playerid
= 0;
93 setscore
->records
[count
].points
= user_record
->points
;
94 setscore
->records
[count
].time
= user_record
->time
;
100 if( count
== 0 ) return;
101 u32 send_size
= sizeof(netmsg_set_score
) +
102 count
*sizeof(struct netmsg_score_record
);
103 setscore
->record_count
= count
;
105 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
106 hSteamNetworkingSockets
, network_client
.remote
, setscore
, send_size
,
107 k_nSteamNetworkingSend_Reliable
, NULL
);
110 static void send_nickname(void){
111 netmsg_set_nickname nick
;
112 nick
.inetmsg_id
= k_inetmsg_set_nickname
;
114 memset( nick
.nickname
, 0, 16 );
115 vg_strncpy( steam_username_at_startup
, nick
.nickname
, 16,
116 k_strncpy_allow_cutoff
);
118 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
119 hSteamNetworkingSockets
, network_client
.remote
,
120 &nick
, sizeof(netmsg_set_nickname
),
121 k_nSteamNetworkingSend_Reliable
, NULL
);
123 network_client
.name_update
= 0;
128 static void server_routine_update(void){
130 send_score_request();
134 static void network_send_username(void){
135 netmsg_playerusername
*update
= alloca( sizeof(netmsg_playerusername
)+
136 NETWORK_USERNAME_MAX
);
137 update
->inetmsg_id
= k_inetmsg_playerusername
;
138 update
->index
= 0xff;
140 ISteamFriends
*hSteamFriends
= SteamAPI_SteamFriends();
141 const char *username
= SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends
);
142 u32 chs
= str_utf8_collapse( username
, update
->name
, NETWORK_USERNAME_MAX
);
144 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
145 hSteamNetworkingSockets
, network_client
.remote
,
146 update
, sizeof(netmsg_playerusername
)+chs
+1,
147 k_nSteamNetworkingSend_Reliable
, NULL
);
150 static void network_send_item( enum netmsg_playeritem_type type
){
151 if( !network_client
.remote
)
154 netmsg_playeritem
*item
=
155 alloca( sizeof(netmsg_playeritem
) + ADDON_UID_MAX
);
156 item
->inetmsg_id
= k_inetmsg_playeritem
;
157 item
->type_index
= type
;
160 if( (type
== k_netmsg_playeritem_world0
) ||
161 (type
== k_netmsg_playeritem_world1
) ){
163 addon_reg
*reg
= world_static
.addon_hub
;
165 if( type
== k_netmsg_playeritem_world1
)
166 reg
= world_static
.addon_client
;
169 addon_alias_uid( ®
->alias
, item
->uid
);
175 enum addon_type addon_type
= k_addon_type_none
;
176 if( type
== k_netmsg_playeritem_board
){
177 view_id
= localplayer
.board_view_slot
;
178 addon_type
= k_addon_type_board
;
180 else if( type
== k_netmsg_playeritem_player
){
181 view_id
= localplayer
.playermodel_view_slot
;
182 addon_type
= k_addon_type_player
;
187 struct addon_cache
*cache
= &addon_system
.cache
[addon_type
];
188 vg_pool
*pool
= &cache
->pool
;
190 SDL_AtomicLock( &addon_system
.sl_cache_using_resources
);
191 addon_cache_entry
*entry
= vg_pool_item( pool
, view_id
);
192 addon_alias_uid( &entry
->reg_ptr
->alias
, item
->uid
);
193 SDL_AtomicUnlock( &addon_system
.sl_cache_using_resources
);
196 vg_info( "send equip: [%u] %s\n",
197 item
->type_index
, item
->uid
);
198 u32 chs
= strlen(item
->uid
);
200 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
201 hSteamNetworkingSockets
, network_client
.remote
,
202 item
, sizeof(netmsg_playeritem
)+chs
+1,
203 k_nSteamNetworkingSend_Reliable
, NULL
);
207 static void network_disconnect(void){
208 SteamAPI_ISteamNetworkingSockets_CloseConnection(
209 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 0 );
210 network_client
.remote
= 0;
212 for( int i
=0; i
<vg_list_size(netplayers
.list
); i
++ ){
213 netplayers
.list
[i
].active
= 0;
217 static void on_server_connect_status( CallbackMsg_t
*msg
){
218 SteamNetConnectionStatusChangedCallback_t
*info
= (void *)msg
->m_pubParam
;
219 vg_info( " Connection status changed for %lu\n", info
->m_hConn
);
220 vg_info( " %s -> %s\n",
221 string_ESteamNetworkingConnectionState(info
->m_eOldState
),
222 string_ESteamNetworkingConnectionState(info
->m_info
.m_eState
) );
224 if( info
->m_hConn
== network_client
.remote
){
225 network_client
.state
= info
->m_info
.m_eState
;
227 if( info
->m_info
.m_eState
==
228 k_ESteamNetworkingConnectionState_Connected
){
229 vg_success(" Connected to remote server.. authenticating\n");
231 /* TODO: We should really wait to see if the server is in auth mode
233 u32 size
= sizeof(netmsg_auth
) + network_client
.app_key_length
;
234 netmsg_auth
*auth
= alloca(size
);
235 auth
->inetmsg_id
= k_inetmsg_auth
;
236 auth
->ticket_length
= network_client
.app_key_length
;
237 for( int i
=0; i
<network_client
.app_key_length
; i
++ )
238 auth
->ticket
[i
] = network_client
.app_symmetric_key
[i
];
240 SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
241 hSteamNetworkingSockets
, network_client
.remote
, auth
, size
,
242 k_nSteamNetworkingSend_Reliable
, NULL
);
244 network_send_username();
246 for( u32 i
=0; i
<k_netmsg_playeritem_max
; i
++ ){
247 network_send_item(i
);
250 else if( info
->m_info
.m_eState
==
251 k_ESteamNetworkingConnectionState_ClosedByPeer
){
253 if( info
->m_info
.m_eEndReason
==
254 k_ESteamNetConnectionEnd_Remote_Max
){
255 network_client
.retries
= 40;
257 network_disconnect();
259 else if( info
->m_info
.m_eState
==
260 k_ESteamNetworkingConnectionState_ProblemDetectedLocally
){
261 network_disconnect();
265 //vg_warn( " Recieved signal from unknown connection\n" );
269 static void on_persona_state_change( CallbackMsg_t
*msg
){
270 if( network_client
.remote
){
271 PersonaStateChange_t
*info
= (void *)msg
->m_pubParam
;
273 ISteamUser
*hSteamUser
= SteamAPI_SteamUser();
275 vg_info( "User: %llu, change: %u\n", info
->m_ulSteamID
,
276 info
->m_nChangeFlags
);
278 if( info
->m_ulSteamID
== SteamAPI_ISteamUser_GetSteamID(hSteamUser
) ){
279 if( info
->m_nChangeFlags
& k_EPersonaChangeName
){
280 network_send_username();
286 static void network_connect(void){
287 /* Connect to server if not connected */
288 SteamNetworkingIPAddr remoteAddr
;
290 #ifdef SR_USE_LOCALHOST
291 SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr
, 27402 );
293 const char *server_lon1
= "46.101.34.155:27402";
294 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, server_lon1
);
296 const char *server_lan
= "192.168.1.32:27402";
297 SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr
, server_lan
);
300 SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr
, buf
, 256, 1 );
301 vg_info( "connect to: %s\n", buf
);
303 network_client
.remote
= SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
304 hSteamNetworkingSockets
, &remoteAddr
, 0, NULL
);
307 static void on_inet_scoreboard( SteamNetworkingMessage_t
*msg
){
308 netmsg_scoreboard
*sb
= msg
->m_pData
;
310 u32 base_size
= sizeof(netmsg_scoreboard
)-
311 sizeof(struct netmsg_board
)*vg_list_size(track_infos
),
312 expected
= base_size
+sizeof(struct netmsg_board
)*sb
->board_count
;
314 if( msg
->m_cbSize
!= expected
){
315 vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
316 msg
->m_cbSize
, expected
);
319 if( vg_list_size(track_infos
) > sb
->board_count
)
320 vg_warn( "Server is out of date, not enough boards recieved\n");
321 else if( vg_list_size(track_infos
) < sb
->board_count
)
322 vg_warn( "Client out of date, server sent more boards than we have\n");
324 vg_success( "Recieved new scoreboards from server\n" );
326 for( int i
=0; i
< vg_min(sb
->board_count
,vg_list_size(track_infos
)); i
++){
327 scoreboard_client_data
.boards
[i
] = sb
->boards
[i
];
328 highscores_board_printf( stdout
, sb
->boards
[i
].data
, 10 );
333 /* We dont need to stay on the server currently */
334 SteamAPI_ISteamNetworkingSockets_CloseConnection(
335 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );
338 network_scores_updated
= 1;
341 static void poll_remote_connection(void){
342 SteamNetworkingMessage_t
*messages
[32];
345 for( int i
=0; i
<10; i
++ ){
346 len
= SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
347 hSteamNetworkingSockets
, network_client
.remote
,
348 messages
, vg_list_size(messages
));
353 for( int i
=0; i
<len
; i
++ ){
354 SteamNetworkingMessage_t
*msg
= messages
[i
];
356 if( msg
->m_cbSize
< sizeof(netmsg_blank
) ){
357 vg_warn( "Discarding message (too small: %d)\n", msg
->m_cbSize
);
361 netmsg_blank
*tmp
= msg
->m_pData
;
363 if( (tmp
->inetmsg_id
>= 200) && (tmp
->inetmsg_id
< 300) ){
364 player_remote_rx_200_300( msg
);
367 SteamAPI_SteamNetworkingMessage_t_Release( msg
);
372 static void network_update(void){
376 ESteamNetworkingConnectionState state
= network_client
.state
;
378 if( state
== k_ESteamNetworkingConnectionState_Connected
){
379 poll_remote_connection();
380 f64 frame_delta
= vg
.time_real
- network_client
.last_frame
;
382 if( frame_delta
> 0.1 ){
383 network_client
.last_frame
= vg
.time_real
;
384 remote_player_send_playerframe();
387 remote_player_debug_update();
390 if( (state
== k_ESteamNetworkingConnectionState_Connecting
) ||
391 (state
== k_ESteamNetworkingConnectionState_FindingRoute
) ){
395 f64 waited
= vg
.time_real
- network_client
.last_attempt
,
398 if( network_client
.retries
> 5 )
401 if( waited
< min_wait
)
405 network_client
.retries
++;
406 network_client
.last_attempt
= vg
.time_real
;
411 static void network_init(void){
412 vg_console_reg_var( "network_info", &network_client
.network_info
,
413 k_var_dtype_i32
, VG_VAR_PERSISTENT
);
415 steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack
,
416 on_server_connect_status
);
417 steam_register_callback( k_iPersonaStateChange
,
418 on_persona_state_change
);
419 request_auth_ticket();
423 static void network_end(void){
424 /* TODO: Send buffered highscores that were not already */
425 if( (network_client
.state
== k_ESteamNetworkingConnectionState_Connected
) ||
426 (network_client
.state
== k_ESteamNetworkingConnectionState_Connecting
) )
428 SteamAPI_ISteamNetworkingSockets_CloseConnection(
429 hSteamNetworkingSockets
, network_client
.remote
, 0, NULL
, 1 );