#include "network_msg.h"
#include "network_common.h"
#include "player_remote.h"
+#include "world_sfd.h"
static void scores_update(void);
k_nSteamNetworkingSend_Reliable, NULL );
}
+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->cur.co;
+ vg_info( "Request scoreboard. Info (%u):\n", body->cur.co );
+ vg_msg_print( body, len );
+
+ if( body->error != k_vg_msg_error_OK ){
+ vg_error( "Body not OK\n" );
+ return;
+ }
+ }
+
+ 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;
+ }
+
+ u32 l = 0;
+ if( vg_msg_seekframe( body, "rows" ) ){
+ while( vg_msg_seekframe( body, NULL ) ){
+ const char *username = vg_msg_getkvstr( body, "username" );
+ sfd_encode( l ++, username );
+ vg_msg_skip_frame( body );
+ }
+ }
+}
+
+/* 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;
+ vg_msg_init( &data, req->q, 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;
+ if( res->status == k_request_status_ok ){
+ vg_msg_init( &data, res->q, msg->m_cbSize - sizeof(netmsg_request) );
+ vg_success( "Response to #%d:\n", (i32)res->id );
+ vg_msg_print( &data, data.max );
+ 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;
hSteamNetworkingSockets, network_client.remote,
item, sizeof(netmsg_playeritem)+chs+1,
k_nSteamNetworkingSend_Reliable, NULL );
-
}
static void network_disconnect(void){
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 );
}
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,