[carveJwlIkooP6JGAAIwe30JlM.git] / player_remote.c

#include "player_remote.h"
#include "skeleton.h"
#include "player_render.h"
#include "network_common.h"
#include "addon.h"
#include "font.h"
#include "gui.h"
#include "ent_miniworld.h"

static i32 k_show_own_name = 0;

static void player_remote_clear( struct network_player *player ){
   addon_cache_unwatch( k_addon_type_player, player->playermodel_view_slot );
   addon_cache_unwatch( k_addon_type_board, player->board_view_slot );

   memset( player, 0, sizeof(*player) );
   strcpy( player->username, "unknown" );
   player->subsystem = k_player_subsystem_invalid;
}

/* 
 * re-attatches addon_reg pointers on the remote client if we have the same
 * world loaded.
 */
static void relink_remote_player_worlds( u32 client_id ){
   struct network_player *player = &netplayers.list[client_id];

   addon_alias q[2];
   addon_uid_to_alias( player->items[k_netmsg_playeritem_world0], &q[0] );
   addon_uid_to_alias( player->items[k_netmsg_playeritem_world1], &q[1] );

   /*
    * currently in 10.23, the hub world will always be the same.
    * this might but probably wont change in the future
    */
   for( u32 i=0; i<k_world_max; i++ ){
      addon_reg *reg = world_static.instance_addons[ i ];

      player->world_match[i] = 0;

      if( reg ){
         if( addon_alias_eq( &q[i], &world_static.instance_addons[i]->alias ) )
            player->world_match[i] = 1;
      }
   }
}

/* 
 * re-attatches addon_reg pointers on the remote client if we have the mod 
 * installed locally.
 *
 * Run if local worlds change
 */
static void relink_all_remote_player_worlds(void){
   for( u32 i=0; i<vg_list_size(netplayers.list); i++ ){
      struct network_player *player = &netplayers.list[i];
      if( player->active )
         relink_remote_player_worlds(i);
   }
}

static void player_remote_update_friendflags( struct network_player *remote ){
   ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
   remote->isfriend = SteamAPI_ISteamFriends_HasFriend( hSteamFriends,
                        remote->steamid, k_EFriendFlagImmediate );
   remote->isblocked = SteamAPI_ISteamFriends_HasFriend( hSteamFriends,
                        remote->steamid, k_EFriendFlagBlocked );
}

static void player_remote_rx_200_300( SteamNetworkingMessage_t *msg ){
   netmsg_blank *tmp = msg->m_pData;

   if( tmp->inetmsg_id == k_inetmsg_playerjoin ){
      netmsg_playerjoin *playerjoin = msg->m_pData;
      if( !packet_minsize( msg, sizeof(*playerjoin) )) return;

      if( playerjoin->index < vg_list_size(netplayers.list) ){
         struct network_player *player = &netplayers.list[ playerjoin->index ];
         player_remote_clear( player );
         player->active = 1;
         player->steamid = playerjoin->steamid;
         player_remote_update_friendflags( player );

         /* TODO: interpret the uids */
         player->board_view_slot = 0;
         player->playermodel_view_slot = 0;

         struct interp_buffer *buf = &netplayers.interp_data[playerjoin->index];
         buf->t = -99999999.9;
         for( u32 i=0; i<vg_list_size(buf->frames); i ++ ){
            buf->frames[i].active = 0;
         }

         vg_info( "#%u joined friend: %d, blocked: %d\n", 
                  playerjoin->index, player->isfriend, player->isblocked );
      }
      else {
         vg_error( "inetmsg_playerjoin: player index out of range\n" );
      }
   }
   else if( tmp->inetmsg_id == k_inetmsg_playerleave ){
      netmsg_playerleave *playerleave = msg->m_pData;
      if( !packet_minsize( msg, sizeof(*playerleave) )) return;
      
      if( playerleave->index < vg_list_size(netplayers.list) ){
         struct network_player *player = &netplayers.list[ playerleave->index ];
         player_remote_clear( player );
         player->active = 0;
         vg_info( "player leave (%d)\n", playerleave->index );
      }
      else {
         vg_error( "inetmsg_playerleave: player index out of range\n" );
      }
   }
   else if( tmp->inetmsg_id == k_inetmsg_playerusername ){
      netmsg_playerusername *update = msg->m_pData;
      if( !packet_minsize( msg, sizeof(*update) )) return;

      if( update->index < vg_list_size(netplayers.list) ){
         struct network_player *player = &netplayers.list[ update->index ];

         network_msgstring( update->name, msg->m_cbSize, sizeof(*update),
                            player->username, sizeof(player->username) );

         vg_info( "#%u changed username to: %s\n", 
                  update->index, player->username );
      }
      else {
         vg_error( "inetmsg_playerleave: player index out of range\n" );
      }
   }
   else if( tmp->inetmsg_id == k_inetmsg_playerframe ){
      u32 datasize = msg->m_cbSize - sizeof(netmsg_playerframe);
      
      if( datasize > sizeof(union interp_animdata) ){
         vg_error( "Player frame data exceeds animdata size\n" );
         return;
      }
      
      netmsg_playerframe *frame = msg->m_pData;
      if( frame->client >= vg_list_size(netplayers.list) ){
         vg_error( "inetmsg_playerframe: player index out of range\n" );
         return;
      }

      if( frame->subsystem >= k_player_subsystem_max ){
         vg_error( "inetmsg_playerframe: subsystem out of range\n" );
         return;
      }

      struct interp_buffer *ib = &netplayers.interp_data[ frame->client ];
      struct interp_frame *dest = NULL;

      f64 min_time = INFINITY;
      for( u32 i=0; i<vg_list_size(ib->frames); i++ ){
         struct interp_frame *ifr = &ib->frames[i];

         if( !ifr->active ){
            dest = ifr;
            break;
         }

         if( ifr->timestamp < min_time ){
            min_time = ifr->timestamp;
            dest = ifr;
         }
      }

      dest->active = 1;
      dest->subsystem = frame->subsystem;
      dest->instance_id = frame->instance_id;

      bitpack_ctx ctx = {
         .mode = k_bitpack_decompress,
         .buffer = frame->animdata,
         .buffer_len = datasize,
         .bytes = 0,
      };
      
      /* animation 
       * -------------------------------------------------------------*/

      dest->timestamp = frame->timestamp;
      dest->boundary_hash = frame->boundary_hash;

      struct network_player *player = &netplayers.list[ frame->client ];
      struct player_subsystem_interface *sys = 
         player_subsystems[ frame->subsystem ];

      if( sys->network_animator_exchange ){
         memset( &dest->data, 0, sys->animator_size );
         sys->network_animator_exchange( &ctx, &dest->data );
      }
      else {
         bitpack_bytes( &ctx, sys->animator_size, sys->animator_data );
      }

      /* sfx
       * -------------------------------------------------------------*/
      
      for( u32 i=0; i<frame->sound_effects; i ++ ){
         struct net_sfx sfx;
         net_sfx_exchange( &ctx, &sfx );

         f64 t = (frame->timestamp - NETWORK_FRAMERATE) + 
                 (sfx.subframe*NETWORK_FRAMERATE);

         f32 remaining = t - ib->t;

         if( remaining <= 0.0f )
            net_sfx_play( &sfx );
         else{
            struct net_sfx *dst = NULL;

            for( u32 j=0; j<NETWORK_SFX_QUEUE_LENGTH; j ++ ){
               struct net_sfx *sj = &netplayers.sfx_queue[j];
               if( sj->system == k_player_subsystem_invalid ){
                  dst = sj;
                  break;
               }

               if( sj->priority < sfx.priority )
                  dst = sj;
            }

            *dst = sfx;
            dst->subframe = remaining;
         }
      }

      player->subsystem = frame->subsystem;
      player->down_bytes += msg->m_cbSize;
   }
   else if( tmp->inetmsg_id == k_inetmsg_playeritem ){
      netmsg_playeritem *item = msg->m_pData;
      if( !packet_minsize( msg, sizeof(*item)+1 )) return;

      if( item->client >= vg_list_size(netplayers.list) ){
         vg_error( "inetmsg_playerframe: player index out of range\n" );
         return;
      }

      if( item->type_index >= k_netmsg_playeritem_max ){
         vg_warn( "Client #%d invalid equip type %u\n", 
                  (i32)item->client, (u32)item->type_index );
         return;
      }

      vg_info( "Client #%d equiped: [%s] %s\n", 
               item->client,
               (const char *[]){[k_netmsg_playeritem_board]="board",
                                [k_netmsg_playeritem_player]="player",
                                [k_netmsg_playeritem_world0]="world0",
                                [k_netmsg_playeritem_world1]="world1"
               }[item->type_index], item->uid );

      struct network_player *player = &netplayers.list[ item->client ];
      char *uid = player->items[ item->type_index ];

      network_msgstring( item->uid, msg->m_cbSize, sizeof(*item),
                         uid, ADDON_UID_MAX );

      if( item->type_index == k_netmsg_playeritem_board ){
         addon_cache_unwatch( k_addon_type_board, player->board_view_slot );
         player->board_view_slot = 
            addon_cache_create_viewer_from_uid( k_addon_type_board, uid );
      }
      else if( item->type_index == k_netmsg_playeritem_player ){
         addon_cache_unwatch( k_addon_type_player, 
                              player->playermodel_view_slot );
         player->playermodel_view_slot =
            addon_cache_create_viewer_from_uid( k_addon_type_player, uid );
      }
      else if( (item->type_index == k_netmsg_playeritem_world0) ||
               (item->type_index == k_netmsg_playeritem_world1) ){
         relink_remote_player_worlds( item->client );
      }
   }
   else if( tmp->inetmsg_id == k_inetmsg_chat ){
      netmsg_chat *chat = msg->m_pData;
      
      struct network_player *player = &netplayers.list[ chat->client ];
      network_msgstring( chat->msg, msg->m_cbSize, sizeof(netmsg_chat),
                         player->chat, NETWORK_MAX_CHAT );
      player->chat_time = vg.time_real;
      vg_info( "[%d]: %s\n", chat->client, player->chat );
   }
}

/*
 * Write localplayer pose to network
 */
static void remote_player_send_playerframe(void){
   u8 sysid = localplayer.subsystem;
   if( sysid >= k_player_subsystem_max ) return;

   struct player_subsystem_interface *sys = player_subsystems[sysid];

   if( sys->animator_size ){
      u32 max_buf_size = sys->animator_size + sizeof(localplayer.sfx_buffer),
          base_size = sizeof(struct netmsg_playerframe),
          max_packet = base_size + max_buf_size;

      netmsg_playerframe *frame = alloca( max_packet );
      frame->inetmsg_id = k_inetmsg_playerframe;
      frame->client = 0xff;
      frame->subsystem = localplayer.subsystem;
      frame->instance_id = world_static.active_instance;

      bitpack_ctx ctx = {
         .mode = k_bitpack_compress,
         .buffer = frame->animdata,
         .buffer_len = max_buf_size,
         .bytes = 0
      };

      /* animation 
       * -----------------------------------------------*/

      frame->timestamp = vg.time_real;
      frame->boundary_hash = localplayer.boundary_hash;
      if( sys->network_animator_exchange )
         sys->network_animator_exchange( &ctx, sys->animator_data );
      else
         bitpack_bytes( &ctx, sys->animator_size, sys->animator_data );

      /* sfx
       * ---------------------------------------------*/

      frame->sound_effects = localplayer.sfx_buffer_count;
      for( u32 i=0; i<localplayer.sfx_buffer_count; i ++ )
         net_sfx_exchange( &ctx, &localplayer.sfx_buffer[i] );

      u32 wire_size = base_size + ctx.bytes;
      netplayers.up_bytes += wire_size;

      SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
            hSteamNetworkingSockets, network_client.remote, 
            frame, wire_size,
            k_nSteamNetworkingSend_Unreliable, NULL );
   }
}

/*
 * Updates network traffic stats
 */
static void remote_player_debug_update(void){
   if( (vg.time_real - netplayers.last_data_measurement) > 1.0 ){
      netplayers.last_data_measurement = vg.time_real;
      u32 total_down = 0;

      for( u32 i=0; i<vg_list_size(netplayers.list); i++ ){
         struct network_player *player = &netplayers.list[i];
         if( player->active ){
            total_down += player->down_bytes;
            player->down_kbs = ((f32)player->down_bytes)/1024.0f;
            player->down_bytes = 0;
         }
      }

      netplayers.down_kbs = ((f32)total_down)/1024.0f;
      netplayers.up_kbs = ((f32)netplayers.up_bytes)/1024.0f;
      netplayers.up_bytes = 0;
   }
}

/*
 * Debugging information
 */
static void remote_player_network_imgui( m4x4f pv ){
   if( network_client.user_intent == k_server_intent_online ){
      if( !(steam_ready &&
         (network_client.state == k_ESteamNetworkingConnectionState_Connected)))
      {
         char buf[128];
         vg_str str;
         vg_strnull( &str, buf, sizeof(buf) );
         u32 fg = 0;
         network_status_string( &str, &fg );
         ui_text( (ui_rect){ vg.window_x - 200, 0, 200, 48 }, buf, 1, 
                  k_ui_align_middle_center, fg );
      }
   }

   if( !network_client.network_info ) 
      return;

   ui_rect panel = { (vg.window_x / 2) - 200, 0, 400, 600 };
   ui_fill( panel, (ui_colour(k_ui_bg)&0x00ffffff)|0x50000000 );

   char buf[512];
   const char *netstatus = "PROGRAMMING ERROR";

   struct { enum ESteamNetworkingConnectionState state; const char *str; }
   states[] = {
           { k_ESteamNetworkingConnectionState_None, "None" },
           { k_ESteamNetworkingConnectionState_Connecting, 
         (const char *[]){"Connecting -",
                          "Connecting /",
                          "Connecting |",
                          "Connecting \\",
                          }[(u32)(vg.time_real/0.25) & 0x3 ] },
           { k_ESteamNetworkingConnectionState_FindingRoute, "Finding Route" },
           { k_ESteamNetworkingConnectionState_Connected, "Connected" },
           { k_ESteamNetworkingConnectionState_ClosedByPeer, "Closed by peer" },
           { k_ESteamNetworkingConnectionState_ProblemDetectedLocally, 
         "Problem Detected Locally" },
           { k_ESteamNetworkingConnectionState_FinWait, "Fin Wait" },
           { k_ESteamNetworkingConnectionState_Linger, "Linger" },
           { k_ESteamNetworkingConnectionState_Dead, "Dead" }
   };
   for( u32 i=0; i<vg_list_size(states); i ++ ){
      if( states[i].state == network_client.state ){
         netstatus = states[i].str;
         break;
      }
   }
   snprintf( buf, 512, "Network: %s", netstatus );
   ui_info( panel, buf );
   ui_info( panel, "---------------------" );

   if( network_client.state == k_ESteamNetworkingConnectionState_Connected ){
      ui_info( panel, "#-1: localplayer" );
      
      snprintf( buf, 512, "U%.3f/D%.3fkbs", 
                netplayers.up_kbs, netplayers.down_kbs );
      ui_info( panel, buf );

      for( u32 i=0; i<vg_list_size(netplayers.list); i++ ){
         struct network_player *player = &netplayers.list[i];
         if( player->active ){
            const char *sysname = "invalid";

            if( player->subsystem < k_player_subsystem_max ){
               sysname = player_subsystems[ player->subsystem ]->name;
            }
            snprintf( buf, 512, "#%u: %s [%s] D%.1fkbs", 
                      i, player->username, sysname, player->down_kbs );
            ui_info( panel, buf );
         }
      }
   }
   else {
      ui_info( panel, "offline" );
   }
}

static void remote_player_effect( struct network_player *player, 
                                  player_pose *final_pose ){
   /* effects */
}

/*
 * write the remote players final_mtx 
 */
static void pose_remote_player( u32 index, 
                                struct interp_frame *f0,
                                struct interp_frame *f1 ){

   struct network_player *player = &netplayers.list[ index ];

   struct interp_buffer *buf = &netplayers.interp_data[ index ];
   struct skeleton *sk = &localplayer.skeleton;
   m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*index ];
   struct player_board_pose *board_pose = &netplayers.board_poses[index];

   struct player_subsystem_interface *sys0 = player_subsystems[f0->subsystem],
                                     *sys1 = NULL;

   struct player_board *board = 
      addon_cache_item_if_loaded( k_addon_type_board, player->board_view_slot );

   player_pose pose0, pose1, posed;
   sys0->pose( &f0->data, &pose0 );

   u8 instance_id = 0;

   if( f1 ){
      f32 t = (buf->t - f0->timestamp) / (f1->timestamp - f0->timestamp);
          t = vg_clampf( t, 0.0f, 1.0f );

      sys1 = player_subsystems[f1->subsystem];
      sys1->pose( &f1->data, &pose1 );

      u16 bounds = f0->boundary_hash^f1->boundary_hash;

      if( bounds & NETMSG_BOUNDARY_BIT )
         t = 1.0f;

      if( bounds & NETMSG_GATE_BOUNDARY_BIT ){
         /* TODO: Extra work retransforming the root_co, instance_id.. etc */
         t = 1.0f;
      }

      instance_id = f1->instance_id;
      lerp_player_pose( &pose0, &pose1, t, &posed );
      effect_blink_apply( &player->effect_data.blink, &posed, vg.time_delta );

      apply_full_skeleton_pose( sk, &posed, final_mtx );

      if( t < 0.5f ){
         if( sys0->effects ) 
            sys0->effects( &f0->data, final_mtx, board, &player->effect_data );
      }
      else{
         if( sys1->effects ) 
            sys1->effects( &f1->data, final_mtx, board, &player->effect_data );
      }

      memcpy( board_pose, &posed.board, sizeof(*board_pose) );
   }
   else {
      instance_id = f0->instance_id;
      effect_blink_apply( &player->effect_data.blink, &pose0, vg.time_delta );
      apply_full_skeleton_pose( sk, &pose0, final_mtx );
      if( sys0->effects ) 
         sys0->effects( &f0->data, final_mtx, board, &player->effect_data );
      memcpy( board_pose, &pose0.board, sizeof(*board_pose) );
   }

   if( player->world_match[ instance_id ] )
      player->active_world = &world_static.instances[ instance_id ];
}

/* 
 * animate remote player and store in final_mtx
 */
static void animate_remote_player( u32 index ){

   /*
    * Trys to keep the cursor inside the buffer
    */
   f64 min_time = -999999999.9,
       max_time =  999999999.9,
       abs_max_time = -999999999.9;

   struct interp_frame *minframe = NULL,
                       *maxframe = NULL,
                       *abs_max_frame = NULL;

   struct interp_buffer *buf = &netplayers.interp_data[index];
   for( u32 i=0; i<vg_list_size(buf->frames); i ++ ){
      struct interp_frame *ifr = &buf->frames[i];

      if( ifr->active ){
         if( (ifr->timestamp > min_time) && (ifr->timestamp < buf->t) ){
            min_time = ifr->timestamp;
            minframe = ifr;
         }

         if( (ifr->timestamp < max_time) && (ifr->timestamp > buf->t) ){
            max_time = ifr->timestamp;
            maxframe = ifr;
         }

         if( ifr->timestamp > abs_max_time ){
            abs_max_time = ifr->timestamp;
            abs_max_frame = ifr;
         }
      }
   }

   struct network_player *player = &netplayers.list[ index ];
   if( player->active != 2 )
      player->active_world = NULL;
   
   if( minframe && maxframe ){
      pose_remote_player( index, minframe, maxframe );
      buf->t += vg.time_frame_delta;
   }
   else {
      buf->t = abs_max_time - 0.25;

      if( abs_max_frame )
         pose_remote_player( index, abs_max_frame, NULL );
      else 
         return;
   }
}

/*
 * Update full final_mtx for all remote players
 */
static void animate_remote_players(void){
   for( u32 i=0; i<vg_list_size(netplayers.list); i ++ ){
      struct network_player *player = &netplayers.list[i];
      if( !player->active ) continue;

      animate_remote_player( i );
   }
}

/*
 * Draw remote players
 */
static void render_remote_players( world_instance *world, camera *cam ){
   SDL_AtomicLock( &addon_system.sl_cache_using_resources );
   struct skeleton *sk = &localplayer.skeleton;

   for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
      struct network_player *player = &netplayers.list[i];
      if( !player->active || player->isblocked ) continue;
      if( player->active_world != world ) continue;
      
      m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*i ];

      struct player_model *model = 
         addon_cache_item_if_loaded( k_addon_type_player, 
                                     player->playermodel_view_slot );

      if( !model ) model = &localplayer.fallback_model;
      render_playermodel( cam, world, 0, model, sk, final_mtx );

      struct player_board *board = 
         addon_cache_item_if_loaded( k_addon_type_board,
                                     player->board_view_slot );
      render_board( cam, world, board, final_mtx[localplayer.id_board],
                     &netplayers.board_poses[ i ], k_board_shader_player );
   }

   SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
}

static int remote_players_randomize( int argc, const char *argv[] ){
   for( int i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
      struct network_player *player = &netplayers.list[i];

      player->active = (vg_randu32() & 0x1)? 2: 0;
      player->isfriend = vg_randu32() & vg_randu32() & 0x1;
      player->isblocked = vg_randu32() & vg_randu32() & vg_randu32() & 0x1;
      player->world_match[ 0 ] = vg_randu32() & 0x1;
      player->world_match[ 1 ] = 0;

      if( player->world_match[0] )
         player->active_world = &world_static.instances[0];
      else
         player->active_world = NULL;

      for( int i=0; i<sizeof(player->username)-1; i ++ ){
         player->username[i] = 'a' + (vg_randu32() % 30);
         player->username[i+1] = '\0';

         if( (vg_randu32() % 8) == 3 )
            break;
      }

      for( int i=0; i<3; i ++ ){
         player->medals[i] = vg_randu32() % 3;
      }

      v3f pos;

      vg_rand_sphere( pos );
      v3_muladds( localplayer.rb.co, pos, 100.0f,
                  netplayers.final_mtx[ i*localplayer.skeleton.bone_count][3] );
   }

   return 0;
}

static void remote_players_init(void){
   vg_console_reg_cmd( "add_test_players", remote_players_randomize, NULL );
   vg_console_reg_var( "k_show_own_name", &k_show_own_name, 
                       k_var_dtype_i32, 0 );
   for( u32 i=0; i<NETWORK_SFX_QUEUE_LENGTH; i ++ ){
      netplayers.sfx_queue[i].system = k_player_subsystem_invalid;
   }
}

static void remote_sfx_pre_update(void){
   for( u32 i=0; i<NETWORK_SFX_QUEUE_LENGTH; i ++ ){
      struct net_sfx *si = &netplayers.sfx_queue[i];

      if( si->system != k_player_subsystem_invalid ){
         si->subframe -= vg.time_frame_delta;
         if( si->subframe <= 0.0f ){
            net_sfx_play( si );
            si->system = k_player_subsystem_invalid;
         }
      }
   }
}

/*
 * animator->root_co of remote player
 */
static void remote_player_position( int id, v3f out_co ){
   struct skeleton *sk = &localplayer.skeleton;
   m4x3f *final_mtx = &netplayers.final_mtx[ sk->bone_count*id ];
   v3_copy( final_mtx[0][3], out_co );
}

enum remote_player_gui_type {
   k_remote_player_gui_type_stranger,
   k_remote_player_gui_type_friend,
   k_remote_player_gui_type_you,
};

/*
 * Given players' root_co, get the screen point where we should draw tag info.
 */
static int player_tag_position( m4x4f pv, v3f root_co, ui_point out_point ){
   v4f wpos;
   v3_copy( root_co, wpos );
   wpos[1] += 2.0f;
   wpos[3] = 1.0f;

   m4x4_mulv( pv, wpos, wpos );

   if( wpos[3] > 0.0f ){
      v2_muls( wpos, (1.0f/wpos[3]) * 0.5f, wpos );
      v2_add( wpos, (v2f){ 0.5f, 0.5f }, wpos );

      float k_max = 32000.0f;
      
      out_point[0] = vg_clampf(wpos[0] * vg.window_x, -k_max, k_max );
      out_point[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y, -k_max, k_max );
      return 1;
   }
   else
      return 0;
}

/*
 * Draw chat box relative to the root tag position on the screen
 */
static void chat_box( ui_point tag_root, f64 time, const char *message ){
   if( (vg.time_real - time) > 15.0 ) 
      return;

   ui_rect wr;
   wr[2] = ui_text_line_width( message ) + 8;
   wr[3] = vg_ui.font->glyph_height + 2;
   wr[0] = tag_root[0]-(wr[2]/2);
   wr[1] = tag_root[1] - wr[3] - 8;

   ui_fill( wr, ui_opacity( ui_colour(k_ui_bg), 0.23f ) );
   ui_text( wr, message, 1, k_ui_align_middle_center, 0 );
}

/*
 * Draw full imgui for remote player
 */
static void remote_player_nametag( ui_point tag_root, 
                                   struct network_player *player ){
   vg_ui.font = &vg_ui_font_big;

   ui_rect wr;
   wr[2] = VG_MAX( ui_text_line_width( player->username ), 140 ) + 8;
   wr[3] = 32;
   wr[0] = tag_root[0]-(wr[2]/2);
   wr[1] = tag_root[1]-(wr[3]/2);

   ui_fill( wr, ui_opacity( ui_colour(k_ui_bg), 0.23f ) );
   ui_text( wr, player->username, 1, k_ui_align_middle_center, 0 );

   vg_ui.font = &vg_ui_font_small;

   /* medals */
   int cols = 0;
   for( int i=0; i<3; i ++ )
      if( player->medals[i] ) 
         cols ++;

   char buf[32];
   vg_str str;

   if( cols ){
      f32 w = (f32)wr[2] / (f32)cols;
      cols = 0;

      for( int i=0; i<3; i ++ ){
         if( player->medals[i] ){
            ui_rect col = { wr[0] + (f32)cols*w, wr[1] + wr[3], w, 
                           vg_ui.font->glyph_height };

            vg_strnull( &str, buf, 32 );
            vg_strcatch( &str, (char)k_SRglyph_vg_circle );
            vg_strcati32( &str, player->medals[i] );

            ui_text( col, buf, 1, k_ui_align_middle_center, 
                     ui_colour( (enum ui_scheme_colour[]){ 
                        k_ui_yellow, k_ui_gray, k_ui_orange }[i] ) );
            
            cols ++;
         }
      }
   }
}

static void remote_player_world_gui( m4x4f pv, v3f root_co, 
                                     struct network_player *player  ){
   ui_point tag_root;
   if( !player_tag_position( pv, root_co, tag_root ) )
      return;

   if( player ){
      remote_player_nametag( tag_root, player );
      chat_box( tag_root, player->chat_time, player->chat );
   }
   else {
      if( netplayers.chatting )
         chat_box( tag_root, vg.time_real, netplayers.chat_buffer );
      else
         chat_box( tag_root, netplayers.chat_time, netplayers.chat_message );
   }
}

static void remote_player_gui_info( ui_rect box, 
                                    const char *username,
                                    const char *activity, 
                                    enum remote_player_gui_type type,
                                    int in_world ){

   f32 opacity = in_world? 0.6f: 0.3f;

   if( type == k_remote_player_gui_type_you )
      ui_fill( box, ui_opacity( 0xff555555, opacity ) );
   else
      ui_fill( box, ui_opacity( 0xff000000, opacity ) );

   if( type == k_remote_player_gui_type_friend )
      ui_outline( box, -1, ui_opacity( 0xff00c4f0, opacity ), 0 );

   ui_rect top, bottom;
   ui_split_ratio( box, k_ui_axis_h, 0.6666f, 1, top, bottom );

   u32 fg;
   
   if( type == k_remote_player_gui_type_friend )
      fg = ui_colour( k_ui_yellow + (in_world? k_ui_brighter: 0) );
   else
      fg = ui_colour( in_world? k_ui_fg: k_ui_fg+4 );

   vg_ui.font = &vg_ui_font_big;
   ui_text( top, username, 1, k_ui_align_middle_center, fg );
   vg_ui.font = &vg_ui_font_small;

   ui_text( bottom, activity, 1, k_ui_align_middle_center, fg );
}

static void remote_players_imgui_lobby(void){
    /*
    * TODO: send location string over the network */

   ui_px y = 50, width = 200, height = 42, gap = 2,
         x = vg.window_x - width;

   vg_ui.font = &vg_ui_font_big;
   ui_text( (ui_rect){ x, 0, width, height }, 
            "Online Players", 1, k_ui_align_middle_center, 0 );
   vg_ui.font = &vg_ui_font_small;


   ui_rect us = { x, y, width, height };
   /* FIXME: your location */
   remote_player_gui_info( us, steam_username_at_startup, "you",
                           k_remote_player_gui_type_you, 1 );
   y += height + gap;

   for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
      struct network_player *player = &netplayers.list[i];
      if( !player->active || player->isblocked ) continue;

      int in_same_world = player->active_world != world_current_instance();

      if( !player->isfriend && !in_same_world )
         continue;
      
      ui_rect box = { x, y, width, height };
      remote_player_gui_info( box, player->username, 
                              in_same_world? "": "another world", 
                              player->isfriend, in_same_world );
      y += height + gap;
   }
}

static void remote_players_imgui_world( world_instance *world, m4x4f pv,
                                        f32 max_dist, int geo_cull ){
   ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );

   for( u32 i=0; i<NETWORK_MAX_PLAYERS; i++ ){
      struct network_player *player = &netplayers.list[i];
      if( player->active ){
         v3f co;
         remote_player_position( i, co );

         if( !player->active_world )
            continue;

         /* their in our active subworld */
         if( player->active_world != world ){
            m4x3_mulv( global_miniworld.mmdl, co, co );
            co[1] -= 2.0f; /* HACK lol */
         }

         f32 d2 = v3_dist2( co, localplayer.rb.co );

         if( d2 > (max_dist*max_dist) )
            continue;

         f32 dist = sqrtf(d2);
         f32 opacity = 0.95f * sqrtf(((max_dist-dist)/max_dist));

         if( geo_cull ){
            ray_hit hit;
            hit.dist = dist;

            v3f dir;
            v3_sub( co, skaterift.cam.pos, dir );
            v3_normalize( dir );

            if( ray_world( world, skaterift.cam.pos, dir, &hit, 
                           k_material_flag_ghosts ) ){
               opacity *= 0.5f;
            }
         }

         player->opacity = vg_lerpf( player->opacity, opacity,
                                     vg.time_frame_delta * 2.0f );
         
         remote_player_world_gui( pv, co, player );

         vg_ui.colour[3] = player->opacity;
         ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );
      }
   }

   vg_ui.colour[3] = 1.0f;

   remote_player_world_gui( pv, localplayer.rb.co, NULL );
   ui_flush( k_ui_shader_colour, vg.window_x, vg.window_y );
}

static void chat_escape(void){
   netplayers.chatting = -1;
}

static void chat_enter( char *buf, u32 len ){
   vg_strncpy( buf, netplayers.chat_message, NETWORK_MAX_CHAT, 
               k_strncpy_always_add_null );
   netplayers.chatting = -1;
   netplayers.chat_time = vg.time_real;
   chat_send_message( buf );
}

static void remote_players_chat_imgui(void){
   if( netplayers.chatting == 1 ){
      ui_rect box = { 0, 0, 400, 40 },
              window = { 0, 0, vg.window_x, vg.window_y };
      ui_rect_center( window, box );

      struct ui_textbox_callbacks callbacks = {
         .enter = chat_enter,
         .escape = chat_escape
      };

      ui_textbox( box, NULL, 
                  netplayers.chat_buffer, NETWORK_MAX_CHAT, 1,
                  UI_TEXTBOX_AUTOFOCUS, &callbacks );
   }
   else {
      if( netplayers.chatting == -1 ){
         netplayers.chatting = 0;
         srinput.state = k_input_state_resume;
      }
      else {
         if( (skaterift.activity == k_skaterift_default) && 
               button_down( k_srbind_chat ) ){
            netplayers.chatting = 1;
            netplayers.chat_buffer[0] = '\0';
            srinput.state = k_input_state_pause;
         }
      }
   }
}