#include "network_msg.h"
#include "network_common.h"
#include "player_remote.h"
+#include "world.h"
#include "world_sfd.h"
+#include "world_routes.h"
static void scores_update(void);
}
static void network_send_request( netmsg_request *req, vg_msg *body,
- void (*callback)( netmsg_request *res,
- vg_msg *body )){
+ void (*callback)(
+ netmsg_request *res, vg_msg *body,
+ u64 userdata),
+ u64 userdata ){
u32 len = 0;
if( body ){
- len = body->len;
- vg_info( "Request scoreboard. Info (%u):\n", body->len );
- vg_msg_print( 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" );
vg_pool_item( &network_client.request_pool, req->id );
pn->callback = callback;
pn->sendtime = vg.time_real;
+ pn->userdata = userdata;
}
else{
vg_error( "Unable to send request. Pool is full.\n" );
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, "" );
+static void network_scoreboard_callback( netmsg_request *res, vg_msg *body,
+ u64 userdata ){
+ world_instance *world = world_current_instance();
- 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;
- }
-
- /* TODO: frame pointers?? */
+ world_routes_recv_scoreboard( world, body, userdata, res->status );
+ if( userdata == world_sfd.active_route_board )
+ world_sfd_compile_active_scores();
+}
- u32 l = 0;
- vg_msg rows = *body;
- if( vg_msg_seekframe( &rows, "rows", k_vg_msg_first ) ){
- vg_msg entry = rows;
- while( vg_msg_seekframe( &entry, NULL, k_vg_msg_next ) ){
- const char *username = vg_msg_seekkvstr( &entry, "username",
- k_vg_msg_first );
- sfd_encode( l ++, username );
- vg_msg_skip_frame( &entry );
- }
- }
-}
/* mod_uid: world mod uid,
* route_uid: run name (just a string)
- * week: 0 for all-time, n for week #
+ * week:
+ * 0 ALL TIME
+ * 1 CURRENT WEEK
+ * 2 ALL TIME + CURRENT WEEK
+ * .
+ * 10+ specific week index
*/
static void network_request_scoreboard( const char *mod_uid,
const char *route_uid,
- u32 week ){
+ u32 week, u64 userdata ){
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 = {0};
- data.buf = req->q;
- data.max = 512;
+ 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 );
+ network_send_request( req, &data, network_scoreboard_callback, userdata );
+}
+
+static void network_publish_callback( netmsg_request *res, vg_msg *body,
+ u64 userdata ){
+ if( res->status != k_request_status_ok ){
+ vg_error( "Publish laptime, server error #%d\n", (i32)res->status );
+ }
+}
+
+static void network_publish_laptime( const char *mod_uid,
+ const char *route_uid, f64 lap_time ){
+ if( !network_client.remote )
+ return;
+
+ i32 time_centiseconds = lap_time * 100.0;
+
+ netmsg_request *req = alloca( sizeof(netmsg_request) + 512 );
+ req->inetmsg_id = k_inetmsg_request;
+
+ vg_msg data;
+ vg_msg_init( &data, req->q, 512 );
+ vg_msg_wkvstr( &data, "endpoint", "setlap" );
+ vg_msg_wkvstr( &data, "mod", mod_uid );
+ vg_msg_wkvstr( &data, "route", route_uid );
+ vg_msg_wkvi32( &data, "time", time_centiseconds );
+ network_send_request( req, &data, network_publish_callback, 0 );
}
static void network_request_rx_300_400( SteamNetworkingMessage_t *msg ){
netmsg_request *res = (netmsg_request *)msg->m_pData;
vg_msg *body = NULL;
- vg_msg data = {0};
+ vg_msg data;
if( res->status == k_request_status_ok ){
- data.buf = res->q;
- data.len = msg->m_cbSize - sizeof(netmsg_request);
- data.max = data.len;
+ 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 );
+ vg_msg_print( &data, data.max );
body = &data;
}
else {
if( res->id ){
struct network_request *pn =
vg_pool_item( &network_client.request_pool, res->id );
- pn->callback( res, body );
+ pn->callback( res, body, pn->userdata );
vg_pool_unwatch( &network_client.request_pool, res->id );
}
}
if( (type == k_netmsg_playeritem_world0) ||
(type == k_netmsg_playeritem_world1) ){
- addon_reg *reg = world_static.addon_hub;
-
- if( type == k_netmsg_playeritem_world1 )
- reg = world_static.addon_client;
+ enum world_purpose purpose = type - k_netmsg_playeritem_world0;
+ addon_reg *reg = world_static.instance_addons[ purpose ];
if( reg )
addon_alias_uid( ®->alias, item->uid );
hSteamNetworkingSockets, &remoteAddr, 0, NULL );
}
+#if 0
static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
netmsg_scoreboard *sb = msg->m_pData;
network_scores_updated = 1;
}
+#endif
static void poll_remote_connection(void){
SteamNetworkingMessage_t *messages[32];