#include "network_msg.h"
#include "network_common.h"
#include "player_remote.h"
+#include "world.h"
#include "world_sfd.h"
+#include "world_routes.h"
+#include "vg/vg_imgui.h"
+#include "gui.h"
+#include "ent_region.h"
static void scores_update(void);
SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
}
-#if 0
-static void send_score_request(void){
- vg_info( "Requesting scores\n" );
- netmsg_scores_request req;
- req.inetmsg_id = k_inetmsg_scores_request;
-
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
- &req, sizeof(netmsg_scores_request),
- k_nSteamNetworkingSend_Reliable, NULL );
-}
-
-static void send_score_update(void){
- vg_info( "Sending scores\n" );
- u32 size = sizeof(netmsg_set_score) +
- vg_list_size(track_infos)*sizeof(struct netmsg_score_record);
- netmsg_set_score *setscore = alloca( size );
- setscore->inetmsg_id = k_inetmsg_set_score;
-
- int count = 0;
- for( u32 i=0; i<vg_list_size(track_infos); i++ ){
- if( track_infos[i].push ){
- track_infos[i].push = 0;
-
-#if 0
- highscore_record *user_record = highscore_find_user_record( 0, i );
-
- if( !user_record ){
- vg_error( "No score set but tried to upload for track %u\n", i );
- continue;
- }
-#endif
- highscore_record *user_record = &track_infos[i].record;
-
- setscore->records[count].trackid = i;
- setscore->records[count].playerid = 0;
- setscore->records[count].points = user_record->points;
- setscore->records[count].time = user_record->time;
-
- count ++;
- }
- }
-
- if( count == 0 ) return;
- u32 send_size = sizeof(netmsg_set_score) +
- count*sizeof(struct netmsg_score_record);
- setscore->record_count = count;
-
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote, setscore, send_size,
- k_nSteamNetworkingSend_Reliable, NULL );
-}
-
-static void send_nickname(void){
- netmsg_set_nickname nick;
- nick.inetmsg_id = k_inetmsg_set_nickname;
-
- memset( nick.nickname, 0, 16 );
- vg_strncpy( steam_username_at_startup, nick.nickname, 16,
- k_strncpy_allow_cutoff );
-
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
- &nick, sizeof(netmsg_set_nickname),
- k_nSteamNetworkingSend_Reliable, NULL );
-
- network_client.name_update = 0;
-}
-#endif
-
-#if 0
-static void server_routine_update(void){
- send_score_update();
- send_score_request();
-}
-#endif
-
static void network_send_username(void){
+ if( !network_connected() )
+ return;
+
netmsg_playerusername *update = alloca( sizeof(netmsg_playerusername)+
NETWORK_USERNAME_MAX );
update->inetmsg_id = k_inetmsg_playerusername;
k_nSteamNetworkingSend_Reliable, NULL );
}
+static void network_send_region(void){
+ if( !network_connected() )
+ return;
+
+ netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+
+ region->inetmsg_id = k_inetmsg_region;
+ region->client = 0;
+ region->flags = global_ent_region.flags;
+
+ u32 l = vg_strncpy( global_ent_region.location, region->loc,
+ NETWORK_REGION_MAX, k_strncpy_always_add_null );
+
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, network_client.remote,
+ region, sizeof(netmsg_region)+l+1,
+ k_nSteamNetworkingSend_Reliable, NULL );
+}
+
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->cur.co;
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 );
+ world_routes_recv_scoreboard( world, body, userdata, res->status );
+ if( userdata == world_sfd.active_route_board )
+ world_sfd_compile_active_scores();
+}
- 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 #
+ * 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 ){
- if( !network_client.remote )
+ u32 week, u64 userdata ){
+ if( !network_connected() )
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, "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_connected() )
+ 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 ){
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 );
}
}
}
static void network_send_item( enum netmsg_playeritem_type type ){
- if( !network_client.remote )
+ if( !network_connected() )
return;
netmsg_playeritem *item =
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 );
SteamAPI_ISteamNetworkingSockets_CloseConnection(
hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
network_client.remote = 0;
+ network_client.state = k_ESteamNetworkingConnectionState_None;
for( int i=0; i<vg_list_size(netplayers.list); i++ ){
netplayers.list[i].active = 0;
}
}
+static void network_status_string( vg_str *str, u32 *colour ){
+ if( skaterift.demo_mode ){
+ vg_strcat( str, "Offline" );
+ return;
+ }
+
+ if( steam_ready ){
+ if( network_client.user_intent == k_server_intent_offline ){
+ vg_strcat( str, "Offline" );
+ }
+ else {
+ ESteamNetworkingConnectionState state = network_client.state;
+
+ if( state == k_ESteamNetworkingConnectionState_None )
+ vg_strcat( str, "No Connection" );
+ else if( state == k_ESteamNetworkingConnectionState_Connecting ){
+ vg_strcat( str, "Connecting to:\nskaterift.com" );
+
+ if( network_client.retries ){
+ vg_strcat( str, "\n(" );
+ vg_strcati32( str, network_client.retries );
+ vg_strcat( str, " retries)" );
+ }
+ }
+ else if( state == k_ESteamNetworkingConnectionState_Connected ){
+ vg_strcat( str, "Connected to:\nskaterift.com" );
+ *colour = 0xff00a020;
+ }
+ else if( state == k_ESteamNetworkingConnectionState_ClosedByPeer )
+ vg_strcat( str, "Connection Closed" );
+ else if( state == k_ESteamNetworkingConnectionState_FindingRoute )
+ vg_strcat( str, "Finding Route" );
+ else if( state ==
+ k_ESteamNetworkingConnectionState_ProblemDetectedLocally){
+ vg_strcat( str, "Problem Detected\nLocally" );
+ *colour = 0xff0000a0;
+ }
+ else
+ vg_strcat( str, "???" );
+ }
+ }
+ else {
+ vg_strcat( str, "Steam Offline" );
+ *colour = 0xff0000a0;
+ }
+}
+
+static void render_server_status_gui(void){
+ render_fb_bind( gpipeline.fb_workshop_preview, 0 );
+
+ /* HACK */
+ vg_ui.cur_vert = 0;
+ vg_ui.cur_indice = 0;
+ vg_ui.vert_start = 0;
+ vg_ui.indice_start = 0;
+
+ ui_rect r = { 0, 0, 128, 48 };
+
+ char buf[128];
+ vg_str str;
+ vg_strnull( &str, buf, sizeof(buf) );
+
+ u32 bg = 0xff000000;
+ network_status_string( &str, &bg );
+
+ ui_fill( r, bg );
+ ui_text( r, buf, 1, k_ui_align_center, 0 );
+ ui_flush( k_ui_shader_colour, 128, 48 );
+
+ skaterift.rt_textures[ k_skaterift_rt_server_status ] =
+ gpipeline.fb_workshop_preview->attachments[0].id;
+}
+
static void on_server_connect_status( CallbackMsg_t *msg ){
SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
vg_info( " Connection status changed for %lu\n", info->m_hConn );
k_ESteamNetworkingConnectionState_Connected ){
vg_success(" Connected to remote server.. authenticating\n");
+ /* send version info to server */
+ netmsg_version version;
+ version.inetmsg_id = k_inetmsg_version;
+ version.version = NETWORK_SKATERIFT_VERSION;
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, network_client.remote, &version,
+ sizeof(netmsg_version), k_nSteamNetworkingSend_Reliable, NULL );
+
/* TODO: We should really wait to see if the server is in auth mode
* first... */
u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
hSteamNetworkingSockets, network_client.remote, auth, size,
k_nSteamNetworkingSend_Reliable, NULL );
-
- network_send_username();
-
- for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
- network_send_item(i);
- }
}
else if( info->m_info.m_eState ==
k_ESteamNetworkingConnectionState_ClosedByPeer ){
if( info->m_info.m_eEndReason ==
- k_ESteamNetConnectionEnd_Remote_Max ){
+ k_ESteamNetConnectionEnd_Misc_InternalError ){
network_client.retries = 40;
}
network_disconnect();
else{
//vg_warn( " Recieved signal from unknown connection\n" );
}
+
+ render_server_status_gui();
}
static void on_persona_state_change( CallbackMsg_t *msg ){
- if( network_client.remote ){
- PersonaStateChange_t *info = (void *)msg->m_pubParam;
+ if( !network_connected() )
+ return;
- ISteamUser *hSteamUser = SteamAPI_SteamUser();
-
- vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
- info->m_nChangeFlags );
+ PersonaStateChange_t *info = (void *)msg->m_pubParam;
+ ISteamUser *hSteamUser = SteamAPI_SteamUser();
+
+ vg_info( "User: %llu, change: %u\n", info->m_ulSteamID,
+ info->m_nChangeFlags );
+
+ if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
+ if( info->m_nChangeFlags & k_EPersonaChangeName ){
+ network_send_username();
+ }
+ }
- if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) ){
- if( info->m_nChangeFlags & k_EPersonaChangeName ){
- network_send_username();
+ if( info->m_nChangeFlags & k_EPersonaChangeRelationshipChanged ){
+ for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+ struct network_player *rp = &netplayers.list[i];
+ if( rp->steamid == info->m_ulSteamID ){
+ player_remote_update_friendflags( rp );
}
}
}
}
static void network_connect(void){
+ char ip_buf[128];
+ vg_str str;
+ vg_strnull( &str, ip_buf, sizeof(ip_buf) );
+ vg_strcat( &str, network_client.server_adress );
+ vg_strcat( &str, ":" );
+ vg_strcati32( &str, NETWORK_PORT );
+
+ if( !vg_strgood(&str) ) return;
+
/* Connect to server if not connected */
SteamNetworkingIPAddr remoteAddr;
-
-#ifdef SR_USE_LOCALHOST
- SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( &remoteAddr, 27402 );
-#else
- const char *server_lon1 = "46.101.34.155:27402";
- SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lon1 );
-#endif
- const char *server_lan = "192.168.1.32:27402";
- SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, server_lan );
+ SteamAPI_SteamNetworkingIPAddr_ParseString( &remoteAddr, str.buffer );
char buf[256];
SteamAPI_SteamNetworkingIPAddr_ToString( &remoteAddr, buf, 256, 1 );
hSteamNetworkingSockets, &remoteAddr, 0, NULL );
}
-static void on_inet_scoreboard( SteamNetworkingMessage_t *msg ){
- netmsg_scoreboard *sb = msg->m_pData;
+static void network_sign_on_complete(void){
+ vg_success( "Sign on completed\n" );
- u32 base_size = sizeof(netmsg_scoreboard)-
- sizeof(struct netmsg_board)*vg_list_size(track_infos),
- expected = base_size+sizeof(struct netmsg_board)*sb->board_count;
-
- if( msg->m_cbSize != expected ){
- vg_error( "Server scoreboard was corrupted. Size: %u != %u\n",
- msg->m_cbSize, expected );
- }
- else{
- if( vg_list_size(track_infos) > sb->board_count )
- vg_warn( "Server is out of date, not enough boards recieved\n");
- else if( vg_list_size(track_infos) < sb->board_count )
- vg_warn( "Client out of date, server sent more boards than we have\n");
- else
- vg_success( "Recieved new scoreboards from server\n" );
-
- for( int i=0; i < vg_min(sb->board_count,vg_list_size(track_infos)); i++){
- scoreboard_client_data.boards[i] = sb->boards[i];
- highscores_board_printf( stdout, sb->boards[i].data, 10 );
- }
+ /* send our init info */
+ network_send_username();
+ for( u32 i=0; i<k_netmsg_playeritem_max; i ++ ){
+ network_send_item(i);
}
-
-#if 0
- /* We dont need to stay on the server currently */
- SteamAPI_ISteamNetworkingSockets_CloseConnection(
- hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
-#endif
-
- network_scores_updated = 1;
+ network_send_region();
}
static void poll_remote_connection(void){
else if( (tmp->inetmsg_id >= 300) && (tmp->inetmsg_id < 400) ){
network_request_rx_300_400( msg );
}
+ else {
+ if( tmp->inetmsg_id == k_inetmsg_version ){
+ netmsg_version *version = msg->m_pData;
+ if( version->version != NETWORK_SKATERIFT_VERSION ){
+ network_disconnect();
+ /* we dont want to connect to this server ever */
+ network_client.retries = 999;
+ network_client.last_attempt = 999999999.9;
+ vg_error( "version mismatch with server\n" );
+ }
+ else {
+ network_client.remote_version = version->version;
+ network_sign_on_complete();
+ }
+ }
+ }
SteamAPI_SteamNetworkingMessage_t_Release( msg );
}
ESteamNetworkingConnectionState state = network_client.state;
+ if( network_client.user_intent == k_server_intent_offline ){
+ if( state != k_ESteamNetworkingConnectionState_None )
+ network_disconnect();
+
+ return;
+ }
+
if( state == k_ESteamNetworkingConnectionState_Connected ){
poll_remote_connection();
f64 frame_delta = vg.time_real - network_client.last_frame;
}
}
+static void chat_send_message( const char *message ){
+ if( !network_connected() ){
+ return;
+ }
+
+ netmsg_chat *chat = alloca( sizeof(netmsg_chat) + NETWORK_MAX_CHAT );
+ chat->inetmsg_id = k_inetmsg_chat;
+ chat->client = 0;
+
+ u32 l = vg_strncpy( message, chat->msg, NETWORK_MAX_CHAT,
+ k_strncpy_always_add_null );
+
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
+ hSteamNetworkingSockets, network_client.remote,
+ chat, sizeof(netmsg_chat)+l+1,
+ k_nSteamNetworkingSend_Reliable, NULL );
+}
+
+static int cmd_network_send_message( int argc, const char *argv[] ){
+ char buf[ NETWORK_MAX_CHAT ];
+ vg_str str;
+ vg_strnull( &str, buf, NETWORK_MAX_CHAT );
+
+ for( int i=0; i<argc; i ++ ){
+ vg_strcat( &str, argv[i] );
+
+ if( i < argc-1 )
+ vg_strcatch( &str, ' ' );
+ }
+
+ chat_send_message( buf );
+ return 0;
+}
+
static void network_init(void){
vg_console_reg_var( "network_info", &network_client.network_info,
k_var_dtype_i32, VG_VAR_PERSISTENT );
steam_register_callback( k_iPersonaStateChange,
on_persona_state_change );
request_auth_ticket();
+
+ vg_console_reg_cmd( "say", cmd_network_send_message, NULL );
}
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff