/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 *
*/




#ifdef _WIN32
#include <winsock2.h>	// for inet_addr()
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#endif

#include "network/multiui.h"
#include "freespace.h"
#include "network/multi.h"
#include "network/multiutil.h"
#include "network/multimsgs.h"
#include "io/key.h"
#include "io/timer.h"
#include "gamesequence/gamesequence.h"
#include "gamehelp/contexthelp.h"
#include "playerman/player.h"
#include "network/multi_xfer.h"
#include "cmdline/cmdline.h"
#include "network/stand_gui.h"
#include "network/multiteamselect.h"
#include "mission/missioncampaign.h"
#include "mission/missionload.h"
#include "graphics/font.h"
#include "io/mouse.h"
#include "gamesnd/gamesnd.h"
#include "missionui/chatbox.h"
#include "popup/popup.h"
#include "missionui/missiondebrief.h"
#include "network/multi_ingame.h"
#include "network/multi_kick.h"
#include "network/multi_data.h"
#include "network/multi_campaign.h"
#include "network/multi_team.h"
#include "network/multi_pinfo.h"
#include "network/multi_portfwd.h"
#include "network/multi_observer.h"
#include "network/multi_voice.h"
#include "network/multi_endgame.h"
#include "playerman/managepilot.h"
#include "pilotfile/pilotfile.h"
#include "stats/stats.h"
#include "network/multi_pmsg.h"
#include "network/multi_obj.h"
#include "network/multi_log.h"
#include "globalincs/alphacolors.h"
#include "anim/animplay.h"
#include "network/multi_dogfight.h"
#include "missionui/missionpause.h"
#include "ship/ship.h"
#include "osapi/osregistry.h"
#include "mission/missionbriefcommon.h"
#include "missionui/missionscreencommon.h"
#include "parse/parselo.h"
#include "cfile/cfile.h"
#include "network/multi_fstracker.h"
#include "network/multi_sw.h"
#include "menuui/mainhallmenu.h"
#include "debugconsole/console.h"
#include "network/multi_mdns.h"

#include <algorithm>


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER COMMON interface controls
//

// the common text info box stuff. This is lifted almost directly from Alans briefing code (minus the spiffy colored, scrolling
// text crap :)
int Multi_common_text_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		29, 396, 393, 76
	},
	{ // GR_1024
		47, 634, 630, 122
	}
};

int Multi_common_text_max_display[GR_NUM_RESOLUTIONS] = {
	8,		// GR_640
	12,	// GR_1024
};

// Cutoff values for determining the color of the ping text in server select window
// Pings below MULTI_PING_MIN_YELLOW are in green
const int MULTI_PING_MIN_YELLOW = 100;
const int MULTI_PING_MIN_ORANGE = 150;
const int MULTI_PING_MIN_RED = 250;
const int MULTI_PING_MIN_ONE_SECOND = 1000;

char Multi_common_all_text[MULTI_COMMON_MAX_TEXT];
char Multi_common_text[MULTI_COMMON_TEXT_MAX_LINES][MULTI_COMMON_TEXT_MAX_LINE_LENGTH];

// Labels for Mission description
static const char* PRE_CAMPAIGN_DESC =	"Campaign Description:\n";
static const char* PRE_MISSION_DESC  =	"First Mission:\n";
static const char* DOUBLE_NEW_LINE   =  "\n\n";

SCP_string Multi_netgame_common_description;
static SCP_vector<SCP_string> Multi_received_mission_description;

int Multi_common_top_text_line = -1;		// where to start displaying from
int Multi_common_num_text_lines = 0;		// how many lines we have

void multi_common_scroll_text_up();
void multi_common_scroll_text_down();
void multi_common_move_to_bottom();
void multi_common_render_text();
void multi_common_split_text();

void multi_common_scroll_text_up()
{
	Multi_common_top_text_line--;
	if ( Multi_common_top_text_line < 0 ) {
		Multi_common_top_text_line = 0;
		if ( !mouse_down(MOUSE_LEFT_BUTTON) )
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);

	} else {
		gamesnd_play_iface(InterfaceSounds::SCROLL);
	}
}

void multi_common_scroll_text_down()
{
	Multi_common_top_text_line++;
	if ( (Multi_common_num_text_lines - Multi_common_top_text_line) < gr_get_dynamic_font_lines(Multi_common_text_max_display[gr_screen.res]) ) {
		Multi_common_top_text_line--;
		if ( !mouse_down(MOUSE_LEFT_BUTTON) ){
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
	} else {
		gamesnd_play_iface(InterfaceSounds::SCROLL);
	}
}

void multi_common_move_to_bottom()
{
	// if there's nowhere to scroll down, do nothing
	if(Multi_common_num_text_lines <= gr_get_dynamic_font_lines(Multi_common_text_max_display[gr_screen.res])){
		return;
	}
		
	Multi_common_top_text_line = Multi_common_num_text_lines - gr_get_dynamic_font_lines(Multi_common_text_max_display[gr_screen.res]);
}

void multi_common_set_text(const char *str,int auto_scroll)
{
	// make sure it fits
	// store the entire string as well
	if(strlen(str) >= MULTI_COMMON_MAX_TEXT){
		return ;
	} else {
		strcpy_s(Multi_common_all_text,str);
	}
	
	// split the whole thing up
	multi_common_split_text();

	// scroll to the bottom if we're supposed to
	if(auto_scroll){
		multi_common_move_to_bottom();
	}
}

void multi_common_add_text(const char *str,int auto_scroll)
{
	// make sure it fits
	// store the entire string as well
	if((strlen(str) + strlen(Multi_common_all_text)) >= MULTI_COMMON_MAX_TEXT){
		return ;
	} else {
		strcat_s(Multi_common_all_text,str);
	}
	
	// split the whole thing up
	multi_common_split_text();

	// scroll to the bottom if we're supposed to
	if(auto_scroll){
		multi_common_move_to_bottom();
	}
}

void multi_mission_desciption_set(const char* str_in, int msg_index)
{
	if ( !str_in || (msg_index < 1) ) {
		return;
	}

	while (static_cast<size_t>(msg_index) > Multi_received_mission_description.size()) {
		Multi_received_mission_description.push_back("");
	}

	auto index = static_cast<size_t>(msg_index - 1);

	Multi_received_mission_description[index] = str_in;

	// who cares if we don't *yet* have everything for a split second and will look weird
	// for that tiny period of time, just "KISS"
	SCP_string text;

	for (const auto &msg : Multi_received_mission_description) {
		text += msg;
	}

	multi_common_set_text(text.c_str());
}


void multi_common_split_text()
{
	int	n_lines, i;
	int	n_chars[MAX_BRIEF_LINES];
	const char	*p_str[MAX_BRIEF_LINES];

	n_lines = split_str(Multi_common_all_text, Multi_common_text_coords[gr_screen.res][2], n_chars, p_str, MULTI_COMMON_TEXT_MAX_LINES, MULTI_COMMON_TEXT_MAX_LINE_LENGTH, MULTI_COMMON_TEXT_META_CHAR);
	Assert(n_lines != -1);

	for ( i = 0; i < n_lines; i++ ) {
		Assert(n_chars[i] < MULTI_COMMON_TEXT_MAX_LINE_LENGTH); 
		strncpy(Multi_common_text[i], p_str[i], n_chars[i]);
		Multi_common_text[i][n_chars[i]] = 0;
		drop_leading_white_space(Multi_common_text[i]);		
	}

	Multi_common_top_text_line = 0;
	Multi_common_num_text_lines = n_lines;	
}

void multi_common_render_text()
{
	int i, fh, line_count;

	fh = gr_get_font_height();
	
	line_count = 0;
	gr_set_color_fast(&Color_text_normal);
	for ( i = Multi_common_top_text_line; i < Multi_common_num_text_lines; i++ ) {
		if ( line_count >= gr_get_dynamic_font_lines(Multi_common_text_max_display[gr_screen.res]) ){
			break;	
		}
		gr_string(Multi_common_text_coords[gr_screen.res][0], Multi_common_text_coords[gr_screen.res][1] + (line_count*fh), Multi_common_text[i], GR_RESIZE_MENU);		
		line_count++;
	}

	if ( (Multi_common_num_text_lines - Multi_common_top_text_line) > gr_get_dynamic_font_lines(Multi_common_text_max_display[gr_screen.res]) ) {
		gr_set_color_fast(&Color_more_bright);
		gr_string(Multi_common_text_coords[gr_screen.res][0], (Multi_common_text_coords[gr_screen.res][1] + Multi_common_text_coords[gr_screen.res][3])-5, XSTR("more",755), GR_RESIZE_MENU);
	}
}

// common notification messaging stuff
#define MULTI_COMMON_NOTIFY_TIME		3500
int Multi_common_join_y[GR_NUM_RESOLUTIONS] = {
	375,		// GR_640
	605		// GR_1024
};
int Multi_common_create_y[GR_NUM_RESOLUTIONS] = {
	380,		// GR_640
	610		// GR_1024
};

int Multi_common_jw_y[GR_NUM_RESOLUTIONS] = {
	380,		// GR_640
	610		// GR_1024
};

int Multi_common_msg_y[GR_NUM_RESOLUTIONS] = {
	380,		// GR_640
	610		// GR_1024
};

char Multi_common_notify_text[200];
UI_TIMESTAMP Multi_common_notify_stamp;

void multi_common_notify_init()
{
	strcpy_s(Multi_common_notify_text,"");
	Multi_common_notify_stamp = UI_TIMESTAMP::invalid();
}

// add a notification string, drawing appropriately depending on the state/screen we're in
void multi_common_add_notify(const char *str)
{
	if(str){
		strcpy_s(Multi_common_notify_text,str);
		Multi_common_notify_stamp = ui_timestamp(MULTI_COMMON_NOTIFY_TIME);
	}
}

// process/display notification messages
void multi_common_notify_do()
{
	if (Multi_common_notify_stamp.isValid()){
		if (ui_timestamp_elapsed(Multi_common_notify_stamp)){
			Multi_common_notify_stamp = UI_TIMESTAMP::invalid();
		} else {
			int w,h,y;
			gr_get_string_size(&w,&h,Multi_common_notify_text);
			gr_set_color_fast(&Color_white);
			
			// determine where it should be placed based upon which screen we're on
			y = -1;
			switch(gameseq_get_state()){
			case GS_STATE_MULTI_JOIN_GAME :
				y = Multi_common_join_y[gr_screen.res];
				break;
			case GS_STATE_MULTI_HOST_SETUP :
				y = Multi_common_create_y[gr_screen.res];
				break;
			case GS_STATE_MULTI_CLIENT_SETUP :
				y = Multi_common_jw_y[gr_screen.res];
				break;
			case GS_STATE_MULTI_START_GAME :
				y = Multi_common_msg_y[gr_screen.res];
				break;			
			}
			if(y != -1){
				gr_string((gr_screen.max_w_unscaled - w)/2, y, Multi_common_notify_text, GR_RESIZE_MENU);
			}
		}
	}
}

// common icon stuff
int Multi_common_icons[MULTI_NUM_COMMON_ICONS];
//XSTR:OFF
const char *Multi_common_icon_names[MULTI_NUM_COMMON_ICONS] = {
	"DotRed",				// voice denied
	"DotGreen",				// voice recording
	"OvalGreen",			// team 0
	"OvalGreen01",			// team 0 select
	"OvalRed",				// team 1
	"OvalRed01",			// team 1 select
	"mp_coop",				// coop mission
	"mp_teams",				// TvT mission
	"mp_furball",			// furball mission
	"icon-volition",		// volition mission	
	"icon-valid",			// mission is valid
	"cd"						// cd icon
};
//XSTR:ON
// width and height of the icons
int Multi_common_icon_dims[MULTI_NUM_COMMON_ICONS][2] = {
	{11, 11},				// voice denied
	{11, 11},				// voice recording
	{11, 11},				// team 0
	{11, 11},				// team 0 select
	{11, 11},				// team 1
	{11, 11},				// team 1 select
	{18, 11},				// mp coop
	{18, 11},				// mp TvT
	{18, 11},				// mp furball
	{9, 9},					// volition mission	
	{8, 8},					// mission is valid
	{8, 8}					// cd icon
};

void multi_load_common_icons()
{
	int idx;

	if (Is_standalone)
		return;

	// load all icons
	for(idx=0; idx<MULTI_NUM_COMMON_ICONS; idx++){
		Multi_common_icons[idx] = -1;
		Multi_common_icons[idx] = bm_load(Multi_common_icon_names[idx]);
	}
}

void multi_unload_common_icons()
{
	int idx;

	if (Is_standalone)
		return;

	// unload all icons
	for(idx=0; idx<MULTI_NUM_COMMON_ICONS; idx++){
		if(Multi_common_icons[idx] != -1){
			// don't bm_release() here, used in multiple places - taylor
			bm_unload(Multi_common_icons[idx]);
			Multi_common_icons[idx] = -1;
		}
	}
}

// display any relevant voice status icons
void multi_common_voice_display_status()
{	
	switch(multi_voice_status()){
	// i have been denied the voice token
	case MULTI_VOICE_STATUS_DENIED:
		if(Multi_common_icons[MICON_VOICE_DENIED] != -1){
			gr_set_bitmap(Multi_common_icons[MICON_VOICE_DENIED]);
			gr_bitmap(0,0,GR_RESIZE_MENU);
		}
		break;

	// i am currently recording
	case MULTI_VOICE_STATUS_RECORDING:
		if(Multi_common_icons[MICON_VOICE_RECORDING] != -1){
			gr_set_bitmap(Multi_common_icons[MICON_VOICE_RECORDING]);
			gr_bitmap(0,0,GR_RESIZE_MENU);
		}
		break;

	// i am currently playing back sound
	case MULTI_VOICE_STATUS_PLAYING:
		break;

	// the system is currently idle
	case MULTI_VOICE_STATUS_IDLE:
		break;
	}
}

//XSTR:OFF
// palette initialization stuff
#define MULTI_COMMON_PALETTE_FNAME			"InterfacePalette"
//XSTR:ON

int Multi_common_interface_palette = -1;

void multi_common_load_palette();
void multi_common_set_palette();
void multi_common_unload_palette();

// load in the palette if it doesn't already exist
void multi_common_load_palette()
{
	if(Multi_common_interface_palette != -1){
		return;
	}

	Multi_common_interface_palette = bm_load(MULTI_COMMON_PALETTE_FNAME);
	if(Multi_common_interface_palette == -1){
		nprintf(("Network","Error loading multiplayer common palette!\n"));
	}
}

// set the common palette to be the active one
void multi_common_set_palette()
{
	// if the palette is not loaded yet, do so now
	if(Multi_common_interface_palette == -1){
		multi_common_load_palette();
	}
}

// unload the bitmap palette
void multi_common_unload_palette()
{
	if(Multi_common_interface_palette != -1){
		bm_unload(Multi_common_interface_palette);
		Multi_common_interface_palette = -1;
	}
}


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER JOIN SCREEN 
//

#define MULTI_JOIN_NUM_BUTTONS	11

//XSTR:OFF
// bitmaps defs
#define MULTI_JOIN_PALETTE				"InterfacePalette"

static const char *Multi_join_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiJoin",		// GR_640
	"2_MultiJoin"			// GR_1024
};

static const char *Multi_join_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiJoin-M",		// GR_640
	"2_MultiJoin-M"		// GR_1024
};
//XSTR:ON

// slider
const char *Mj_slider_name[GR_NUM_RESOLUTIONS] = {
	"slider",
	"2_slider"
};
int Mj_slider_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		2, 91, 15, 202
	},
	{ // GR_1024
		8, 147, 30, 322
	}
};

// button defs
#define MJ_SCROLL_UP				0
#define MJ_SCROLL_DOWN			1
#define MJ_REFRESH				2
#define MJ_SCROLL_INFO_UP		3
#define MJ_SCROLL_INFO_DOWN	4
#define MJ_JOIN_OBSERVER		5
#define MJ_START_GAME			6
#define MJ_CANCEL					7
#define MJ_HELP					8
#define MJ_OPTIONS				9
#define MJ_ACCEPT					10

// uses MULTI_JOIN_REFRESH_TIME as its timestamp
UI_TIMESTAMP Multi_join_glr_stamp;

#define MULTI_JOIN_PING_TIME     15000        // how often we ping all the known servers
UI_TIMESTAMP Multi_join_ping_stamp;
UI_WINDOW Multi_join_window;											// the window object for the join screen
UI_BUTTON Multi_join_select_button;									// for selecting list items
UI_SLIDER2 Multi_join_slider;											// handy dandy slider
int Multi_join_bitmap;													// the background bitmap

ui_button_info Multi_join_buttons[GR_NUM_RESOLUTIONS][MULTI_JOIN_NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info( "MJ_00",	1,		57,	-1,	-1,	0 ),						// scroll up
		ui_button_info( "MJ_02",	1,		297,	-1,	-1,	2 ),						// scroll down
		ui_button_info( "MJ_03",	10,	338,	65,	364,	3 ),						// refresh
		ui_button_info( "MJ_04",	1,		405,	-1,	-1,	4 ),						// scroll info up
		ui_button_info( "MJ_05",	1,		446,	-1,	-1,	5 ),						// scroll info down
		ui_button_info( "MJ_06",	489,	339,	-1,	-1,	6 ),						// join as observer
		ui_button_info( "MJ_07",	538,	339,	-1,	-1,	7 ),						// create game
		ui_button_info( "MJ_08",	583,	339,	588,	376,	8 ),						// cancel
		ui_button_info( "MJ_09",	534,	426,	-1,	-1,	9 ),						// help
		ui_button_info( "MJ_10",	534,	454,	-1,	-1,	10 ),						// options
		ui_button_info( "MJ_11",	571,	426,	589,	416,	11 ),						// join
	},
	{ // GR_1024
		ui_button_info( "2_MJ_00",	2,		92,	-1,	-1,	0 ),						// scroll up
		ui_button_info( "2_MJ_02",	2,		475,	-1,	-1,	2 ),						// scroll down
		ui_button_info( "2_MJ_03",	16,	541,	104,	582,	3 ),						// refresh
		ui_button_info( "2_MJ_04",	2,		648,	-1,	-1,	4 ),						// scroll info up
		ui_button_info( "2_MJ_05",	2,		713,	-1,	-1,	5 ),						// scroll info down
		ui_button_info( "2_MJ_06",	783,	542,	-1,	-1,	6 ),						// join as observer
		ui_button_info( "2_MJ_07",	861,	542,	-1,	-1,	7 ),						// create game
		ui_button_info( "2_MJ_08",	933,	542,	588,	376,	8 ),						// cancel
		ui_button_info( "2_MJ_09",	854,	681,	-1,	-1,	9 ),						// help
		ui_button_info( "2_MJ_10",	854,	727,	-1,	-1,	10 ),						// options
		ui_button_info( "2_MJ_11",	914,	681,	937,	668,	11 ),						// join
	}
};

#define MULTI_JOIN_NUM_TEXT			13

UI_XSTR Multi_join_text[GR_NUM_RESOLUTIONS][MULTI_JOIN_NUM_TEXT] = {
	{ // GR_640		
		{"Refresh",							1299, 65,	364,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_REFRESH].button},
		{"Join as",							1300,	476,	376,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_JOIN_OBSERVER].button},
		{"Observer",						1301,	467,	385,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_JOIN_OBSERVER].button},
		{"Create",							1408,	535,	376,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_START_GAME].button},	
		{"Game",								1302,	541,	385,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_START_GAME].button},
		{"Cancel",							387,	588,	376,	UI_XSTR_COLOR_PINK, -1, &Multi_join_buttons[0][MJ_CANCEL].button},	
		{"Help",								928,	496,	436,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_HELP].button},
		{"Options",							1036,	479,	460,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[0][MJ_OPTIONS].button},
		{"Join",								1303,	589,	416,	UI_XSTR_COLOR_PINK, -1, &Multi_join_buttons[0][MJ_ACCEPT].button},
		{"Status",							1304,	37,	37,	UI_XSTR_COLOR_GREEN,	-1, NULL},
		{"Server",							1305,	116,	37,	UI_XSTR_COLOR_GREEN, -1, NULL},
		{"Players",							1306,	471,	37,	UI_XSTR_COLOR_GREEN,	-1, NULL},
		{"Ping",								1307,	555,	37,	UI_XSTR_COLOR_GREEN, -1, NULL}
	},
	{ // GR_1024		
		{"Refresh",							1299, 104,	582,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_REFRESH].button},
		{"Join as",							1300,	783,	602,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_JOIN_OBSERVER].button},
		{"Observer",						1301,	774,	611,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_JOIN_OBSERVER].button},		
		{"Create",							1408,	868,	602,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_START_GAME].button},
		{"Game",								1302,	872,	611,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_START_GAME].button},
		{"Cancel",							387,	941,	602,	UI_XSTR_COLOR_PINK, -1, &Multi_join_buttons[1][MJ_CANCEL].button},
		{"Help",								928,	806,	699,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_HELP].button},
		{"Options",							1036,	782,	736,	UI_XSTR_COLOR_GREEN, -1, &Multi_join_buttons[1][MJ_OPTIONS].button},
		{"Join",								1303,	937,	668,	UI_XSTR_COLOR_PINK, -1, &Multi_join_buttons[1][MJ_ACCEPT].button},
		{"Status",							1304,	60,	60,	UI_XSTR_COLOR_GREEN,	-1, NULL},
		{"Server",							1305,	186,	60,	UI_XSTR_COLOR_GREEN, -1, NULL},
		{"Players",							1306,	753,	60,	UI_XSTR_COLOR_GREEN,	-1, NULL},
		{"Ping",								1307,	888,	60,	UI_XSTR_COLOR_GREEN, -1, NULL}
	}
};

// constants for coordinate look ups
#define MJ_X_COORD 0
#define MJ_Y_COORD 1
#define MJ_W_COORD 2
#define MJ_H_COORD 3

#define MULTI_JOIN_SENT_WAIT		10000					// wait this long since a join was sent to allow another
UI_TIMESTAMP Multi_join_sent_stamp;

// game information text areas
int Mj_max_game_items[GR_NUM_RESOLUTIONS] = {
	28,			// GR_640
	46				// GR_1024
};

int Mj_list_y[GR_NUM_RESOLUTIONS] = {
	53,			// GR_640
	77				// GR_1024
};

int Mj_status_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		34, 53, 55, 287
	},
	{ // GR_1024
		53, 77, 57, 459
	}
};

int Mj_game_icon_coords[GR_NUM_RESOLUTIONS][3] = {
	{ // GR_640
		98, 53, 28
	},
	{ // GR_1024
		124, 77, 28
	}
};	

int Mj_speed_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		122, 53, 56, 261
	},
	{ // GR_1024
		152, 77, 56, 261
	}
};	

int Mj_game_name_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		186, 53, 280, 261
	},
	{ // GR_1024
		206, 77, 311, 261
	}
};	

int Mj_players_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		473, 53, 50, 261
	},
	{ // GR_1024
		748, 77, 67, 459
	}
};	

int Mj_ping_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		551, 53, 47, 261
	},
	{ // GR_1024
		880, 77, 48, 459
	}
};	

// game speed labels
#define MJ_NUM_SPEED_LABELS		5
const char *Multi_join_speed_labels[MJ_NUM_SPEED_LABELS] = {
	"< 56k",
	"56k",
	"isdn",
	"cable",
	"t1/adsl+"
};
color *Multi_join_speed_colors[MJ_NUM_SPEED_LABELS] = {
	&Color_bright_red,
	&Color_bright_red,
	&Color_bright_green,
	&Color_bright_green,
	&Color_bright_green
};

int Mj_cd_coords[GR_NUM_RESOLUTIONS] = {
	20, 30
};

//XSTR:OFF
#define IP_CONFIG_FNAME				"tcp.cfg"		// name of the file which contains known TCP addresses

// extents of the entire boundable game info region

int Mj_list_area_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		23, 53, 565, 279 
	},
	{ // GR_1024
		53, 76, 887, 461 
	}
};	

// PXO channel filter
#define MJ_PXO_FILTER_Y				0

// special chars to indicate various status modes for servers
#define MJ_CHAR_STANDALONE			"*"
#define MJ_CHAR_CAMPAIGN			"c"
//XSTR:ON

// various interface indices
int Multi_join_list_start;							// where to start displaying from
int Multi_join_list_selected;						// which item we have selected
active_game *Multi_join_selected_item;			// a pointer to the corresponding active_game

// if we should be sending a join request at the end of the frame
int Multi_join_should_send = -1;

// master tracker details
int Multi_join_frame_count;						// keep a count of frames displayed
int Multi_join_mt_tried_verify;					// already tried verifying the pilot with the tracker
bool Multi_already_tried_stats_submit;

// data stuff for auto joining a game
#define MULTI_AUTOJOIN_JOIN_STAMP		2000
#define MULTI_AUTOJOIN_QUERY_STAMP		2000

int Multi_did_autojoin;
net_addr Multi_autojoin_addr;
UI_TIMESTAMP Multi_autojoin_join_stamp;
UI_TIMESTAMP Multi_autojoin_query_stamp;

// our join request
join_request Multi_join_request;

int Multi_join_overlay_id;

// LOCAL function definitions
void multi_join_check_buttons();
void multi_join_button_pressed(int n);
void multi_join_display_games();
void multi_join_blit_game_status(active_game *game, int y);
void multi_join_load_tcp_addrs();
void multi_join_do_netstuff();
void multi_join_ping_all();
void multi_join_process_select();
void multi_join_list_scroll_up();
void multi_join_list_scroll_down();
void multi_join_list_page_up();
void multi_join_list_page_down();
active_game *multi_join_get_game(int n);
void multi_join_cull_timeouts();
void multi_join_handle_item_cull(int item_index);
void multi_join_send_join_request(int as_observer);
void multi_join_create_game();
int multi_join_maybe_warn();
int multi_join_warn_pxo();
void multi_join_blit_protocol();

DCF(mj_make, "Makes multijoin games (Multiplayer)")
{
	active_game ag, *newitem;
	int idx;
	int idx_max;

	if (dc_optional_string_either("help", "--help")) {
		dc_printf("Usage: mj_make <num_games>\n");
		return;
	}

	dc_stuff_int(&idx_max);

	for(idx = 0; idx < idx_max; idx++){
		// stuff some fake info
		ag.init();
		sprintf(ag.name, "Game %d", idx);
		ag.version = MULTI_FS_SERVER_VERSION;
		ag.comp_version = MULTI_FS_SERVER_VERSION;
		ag.server_addr.addr[0] = (char)idx;
		ag.flags = (AG_FLAG_COOP | AG_FLAG_FORMING | AG_FLAG_STANDALONE);		

		// add the game
		newitem = multi_update_active_games(&ag);

		// timestamp it so we get random timeouts
		if(newitem != NULL){
			// newitem->heard_from_timer = timestamp(Random::next(500, 10000));
		}
	}
}
DCF(mj_remove, "Removes a multijoin game (multiplayer")
{
	int idx;

	if (dc_optional_string_either("help", "--help")) {
		dc_printf("Usage: mj_remove <list_index>\n");
		return;
	}

	dc_stuff_int(&idx);

	// handle any gui details related to deleting this item
	multi_join_handle_item_cull(idx);

	if (Active_games.empty()) {
		return;
	}

	// delete the item
	SCP_list<active_game>::iterator game = Active_games.begin();
	std::advance(game, idx);
	Active_games.erase(game);
}

void multi_join_notify_new_game()
{	
	// reset the # of items	
	Multi_join_slider.set_numberItems(static_cast<int>(Active_games.size()) > Mj_max_game_items[gr_screen.res] ? static_cast<int>(Active_games.size()) - Mj_max_game_items[gr_screen.res] : 0);
	Multi_join_slider.force_currentItem(Multi_join_list_start);
}

int multi_join_autojoin_do()
{
	// if we have an active game on the list, then return a positive value so that we
	// can join the game
	if (!Active_games.empty()) {
		Multi_join_selected_item = &Active_games.front();
		return 1;
	}

	// send out a server_query again
	if ( ui_timestamp_elapsed(Multi_autojoin_query_stamp) ) {
		send_server_query(&Multi_autojoin_addr);
		Multi_autojoin_query_stamp = ui_timestamp(MULTI_AUTOJOIN_QUERY_STAMP);
	}

	return -1;
}

void multi_join_game_init(bool API_Access)
{
	int idx;

	// do the multiplayer init stuff - multi_level_init() now does all net_player zeroing.
	// setup various multiplayer things
	Assert( Game_mode & GM_MULTIPLAYER );
	Assert( Net_player != NULL );

	Netgame.init();

	multi_level_init();		
	Net_player->flags |= NETINFO_FLAG_DO_NETWORKING;	
	Net_player->m_player = Player;
	memcpy(&Net_player->p_info.addr, &Psnet_my_addr, sizeof(Net_player->p_info.addr));

	// load my local netplayer options
	multi_options_local_load(&Net_player->p_info.options, Net_player);	

	game_flush();

	// destroy any chatbox contents which previously existed (from another game)
	chatbox_clear();

	if (!API_Access) {
		// create the interface window
		Multi_join_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
		Multi_join_window.set_mask_bmap(Multi_join_bitmap_mask_fname[gr_screen.res]);

		// load the background bitmap
		Multi_join_bitmap = bm_load(Multi_join_bitmap_fname[gr_screen.res]);
		if (Multi_join_bitmap < 0) {
			// we failed to load the bitmap - this is very bad
			Int3();
		}
	}

	// intialize the endgame system
	multi_endgame_init();	

	// initialize the common notification messaging
	multi_common_notify_init();

	// initialize the common text area
	multi_common_set_text("");	

	// load and use the common interface palette
	multi_common_load_palette();
	multi_common_set_palette();

	if (!API_Access) {
		// load the help overlay
		Multi_join_overlay_id = help_overlay_get_index(MULTI_JOIN_OVERLAY);
		help_overlay_set_state(Multi_join_overlay_id, gr_screen.res, 0);
	}

	// do TCP and VMT specific initialization
	if ( (Multi_options_g.protocol == NET_TCP) && !MULTI_IS_TRACKER_GAME ) {		
		// if this is a TCP (non tracker) game, we'll load up our default address list right now		
		multi_join_load_tcp_addrs();		
	}	

	// initialize any and all timestamps	
	Multi_join_glr_stamp = UI_TIMESTAMP::invalid();
	Multi_join_ping_stamp = UI_TIMESTAMP::invalid();
	Multi_join_sent_stamp = UI_TIMESTAMP::invalid();

	// reset frame count
	Multi_join_frame_count = 0;

	// haven't tried to verify on the tracker yet.
	Multi_join_mt_tried_verify = 0;

	// clear our all game lists to save hassles
	multi_join_clear_game_list();

	if (!API_Access){
		// create the interface buttons
		for(idx=0; idx<MULTI_JOIN_NUM_BUTTONS; idx++){
			// create the object
			Multi_join_buttons[gr_screen.res][idx].button.create(&Multi_join_window,"", Multi_join_buttons[gr_screen.res][idx].x, Multi_join_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

			// set the sound to play when highlighted
			Multi_join_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

			// set the ani for the button
			Multi_join_buttons[gr_screen.res][idx].button.set_bmaps(Multi_join_buttons[gr_screen.res][idx].filename);

			// set the hotspot
			Multi_join_buttons[gr_screen.res][idx].button.link_hotspot(Multi_join_buttons[gr_screen.res][idx].hotspot);
		}

		// create all xstrs
		for(idx=0; idx<MULTI_JOIN_NUM_TEXT; idx++){
			Multi_join_window.add_XSTR(&Multi_join_text[gr_screen.res][idx]);
		}
	}

	Multi_join_should_send = -1;

	// close any previously open chatbox
	chatbox_close();

	if (!API_Access){
		// create the list item select button
		Multi_join_select_button.create(&Multi_join_window, "", Mj_list_area_coords[gr_screen.res][MJ_X_COORD], Mj_list_area_coords[gr_screen.res][MJ_Y_COORD], Mj_list_area_coords[gr_screen.res][MJ_W_COORD], Mj_list_area_coords[gr_screen.res][MJ_H_COORD], 0, 1);
		Multi_join_select_button.hide();

		// slider
		Multi_join_slider.create(&Multi_join_window, Mj_slider_coords[gr_screen.res][MJ_X_COORD], Mj_slider_coords[gr_screen.res][MJ_Y_COORD], Mj_slider_coords[gr_screen.res][MJ_W_COORD], Mj_slider_coords[gr_screen.res][MJ_H_COORD], 0, Mj_slider_name[gr_screen.res], &multi_join_list_scroll_up, &multi_join_list_scroll_down, NULL);
	}
	// make sure that we turn music/sounds back on (will be disabled after playing a mission)
	main_hall_start_music();

	// if starting a network game, then go to the create game screen
	if ( Cmdline_start_netgame ) {
		multi_join_create_game();		
	} else if (Cmdline_connect_addr != nullptr) {
		// joining a game.  Send a join request to the given IP address, and wait for the return.
		psnet_string_to_addr(Cmdline_connect_addr, &Multi_autojoin_addr);

		send_server_query(&Multi_autojoin_addr);
		Multi_autojoin_query_stamp = ui_timestamp(MULTI_AUTOJOIN_QUERY_STAMP);
		Multi_did_autojoin = 0;
	}
}

void multi_join_clear_game_list()
{
	// misc data	
	Multi_join_list_selected = -1;	
	Multi_join_selected_item = nullptr;
	Multi_join_list_start = -1;

	// initialize the active game list
	Active_games.clear();
}

void multi_join_game_do_frame(bool API_Access)
{
	// Because we can get to here through the options screen, we may have PXO games enabled when we're not connected.
	// So we should go back and connect if that's true.
	if (Multi_options_g.pxo && !multi_fs_tracker_inited()) {
		gameseq_post_event(GS_EVENT_PXO);
		return;
	}

	// return here since we will be moving to the next stage anyway -- I don't want to see the backgrounds of
	// all the screens for < 1 second for every screen we automatically move to.
	if ( Cmdline_start_netgame ) {
		return;
	}

	// when joining a network game, wait for the server query to come back, and then join the game
	if ( Cmdline_connect_addr != NULL ) {
		int rval;

		if ( !Multi_did_autojoin ) {
			rval = popup_till_condition(multi_join_autojoin_do, XSTR("&Cancel", 779), XSTR("Joining netgame", 1500) );
			if ( rval == 0 ) {
				// cancel was hit.  Send the user back to the main hall
				gameseq_post_event(GS_EVENT_MAIN_MENU);
				Cmdline_connect_addr = NULL;		// reset this value.
			}

			// when we get here, we have the data -- join the game.
			multi_join_send_join_request(0);
			Multi_autojoin_join_stamp = ui_timestamp(MULTI_AUTOJOIN_JOIN_STAMP);
			Multi_did_autojoin = 1;
		}

		if ( ui_timestamp_elapsed(Multi_autojoin_join_stamp) ) {
			multi_join_send_join_request(0);
			Multi_autojoin_join_stamp = ui_timestamp(MULTI_AUTOJOIN_JOIN_STAMP);
		}
		return;

	}	

	// reset the should send var
	Multi_join_should_send = -1;

	// only do keypresses if we're not in API mode
	if (!API_Access) {
		int k = Multi_join_window.process();

		// process any keypresses
		switch (k) {
		case KEY_ESC:
			if (help_overlay_active(Multi_join_overlay_id)) {
				help_overlay_set_state(Multi_join_overlay_id, gr_screen.res, 0);
			} else {
				if (MULTI_IS_TRACKER_GAME) {
					gameseq_post_event(GS_EVENT_PXO);
				} else {
					gameseq_post_event(GS_EVENT_MAIN_MENU);
				}
				gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			}
			break;

		// page up the game list
		case KEY_PAGEUP:
			multi_join_list_page_up();
			Multi_join_slider.force_currentItem(Multi_join_list_start);
			break;

		case KEY_T:
			multi_pinfo_popup(Net_player);
			break;

		// page down the game list
		case KEY_PAGEDOWN:
			multi_join_list_page_down();
			Multi_join_slider.force_currentItem(Multi_join_list_start);
			break;

		// send out a ping-all
		case KEY_P:
			multi_join_ping_all();
			Multi_join_ping_stamp = ui_timestamp(MULTI_JOIN_PING_TIME);
			break;

		// shortcut to start a game
		case KEY_S:
			multi_join_create_game();
			break;

		// scroll the game list up
		case KEY_UP:
			multi_join_list_scroll_up();
			Multi_join_slider.force_currentItem(Multi_join_list_start);
			break;

		// scroll the game list down
		case KEY_DOWN:
			multi_join_list_scroll_down();
			Multi_join_slider.force_currentItem(Multi_join_list_start);
			break;
		}

		if (mouse_down(MOUSE_LEFT_BUTTON)) {
			help_overlay_set_state(Multi_join_overlay_id, gr_screen.res, 0);
		}
	}

	// do any network related stuff
	multi_join_do_netstuff(); 

	// Don't do any drawing in API mode either
	if (!API_Access) {
		// process any button clicks
		multi_join_check_buttons();

		// process any list selection stuff
		multi_join_process_select();

		// draw the background, etc
		gr_reset_clip();
		GR_MAYBE_CLEAR_RES(Multi_join_bitmap);
		if (Multi_join_bitmap != -1) {
			gr_set_bitmap(Multi_join_bitmap);
			gr_bitmap(0, 0, GR_RESIZE_MENU);
		}
		Multi_join_window.draw();

		// display the active games
		multi_join_display_games();

		// display any text in the info area
		multi_common_render_text();

		// display any pending notification messages
		multi_common_notify_do();

		// draw the help overlay
		help_overlay_maybe_blit(Multi_join_overlay_id, gr_screen.res);

		// flip the buffer
		gr_flip();
	}

	// if we are supposed to be sending a join request
	if(Multi_join_should_send != -1){		
		multi_join_send_join_request(Multi_join_should_send);
	}
	Multi_join_should_send = -1;

	// increment the frame count
	// This is inited and never read as far as I can tell? Remove it? - Mjn
	Multi_join_frame_count++;
}

void multi_join_game_close(bool API_Access)
{
	// unload any bitmaps
	if(!bm_unload(Multi_join_bitmap)){
		nprintf(("General","WARNING : could not unload background bitmap %s\n",Multi_join_bitmap_fname[gr_screen.res]));
	}

	// clear descriptions
	Multi_netgame_common_description.clear();
	Multi_received_mission_description.clear();

	// free up the active game list
	Active_games.clear();

	// cancel mdns queries
	multi_mdns_query_close();

	if (!API_Access) {
		// destroy the UI_WINDOW
		Multi_join_window.destroy();
	}
}

void multi_join_check_buttons()
{
	int idx;
	for(idx=0;idx<MULTI_JOIN_NUM_BUTTONS;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_join_buttons[gr_screen.res][idx].button.pressed()){
			multi_join_button_pressed(idx);
			break;
		}
	}
}

void multi_join_button_pressed(int n)
{

	switch(n){
	case MJ_CANCEL :
		// if we're player PXO, go back there
		if (MULTI_IS_TRACKER_GAME) {
			gameseq_post_event(GS_EVENT_PXO);
		} else {
			gameseq_post_event(GS_EVENT_MAIN_MENU);
		}
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		break;
	case MJ_ACCEPT :
		if(Active_games.empty()){
			multi_common_add_notify(XSTR("No games found!",757));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else if(Multi_join_list_selected == -1){
			multi_common_add_notify(XSTR("No game selected!",758));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else if (Multi_join_sent_stamp.isValid() && !ui_timestamp_elapsed(Multi_join_sent_stamp)) {
			multi_common_add_notify(XSTR("Still waiting on previous join request!",759));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else {			
			// otherwise, if he's already played PXO games, warn him	
			
			if(Player->flags & PLAYER_FLAGS_HAS_PLAYED_PXO){
				if(!multi_join_warn_pxo()){
					break;
				}			
			}
			

			// send the join request here
			Assertion(Multi_join_selected_item != nullptr, "Tried to join a null multi game. Please report!");

			// send a join request packet
			Multi_join_should_send = 0;			
			
			gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		}
		break;

	// help overlay
	case MJ_HELP:
		if(!help_overlay_active(Multi_join_overlay_id)){
			help_overlay_set_state(Multi_join_overlay_id,gr_screen.res,1);
		} else {
			help_overlay_set_state(Multi_join_overlay_id,gr_screen.res,0);
		}
		break;

	// scroll the game list up
	case MJ_SCROLL_UP:
		multi_join_list_scroll_up();
		Multi_join_slider.force_currentItem(Multi_join_list_start);
		break;

	// scroll the game list down
	case MJ_SCROLL_DOWN:
		multi_join_list_scroll_down();
		Multi_join_slider.force_currentItem(Multi_join_list_start);
		break;

	// scroll the info text box up
	case MJ_SCROLL_INFO_UP:
		multi_common_scroll_text_up();
		break;

	// scroll the info text box down
	case MJ_SCROLL_INFO_DOWN:
		multi_common_scroll_text_down();
		break;

	// go to the options screen
	case MJ_OPTIONS:
		gameseq_post_event(GS_EVENT_OPTIONS_MENU);
		break;

	// go to the start game screen	
	case MJ_START_GAME:
		multi_join_create_game();		
		break;

	// refresh the game/server list
	case MJ_REFRESH:	
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		broadcast_game_query();
		break;

	// join a game as an observer
	case MJ_JOIN_OBSERVER:
		if(Active_games.empty()){
			multi_common_add_notify(XSTR("No games found!",757));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else if(Multi_join_list_selected == -1){
			multi_common_add_notify(XSTR("No game selected!",758));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else if (Multi_join_sent_stamp.isValid() && !ui_timestamp_elapsed(Multi_join_sent_stamp)) {
			multi_common_add_notify(XSTR("Still waiting on previous join request!",759));
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		} else {			
			// send the join request here
			Assertion(Multi_join_selected_item != nullptr, "Tried to join a null multi game. Please report!");

			Multi_join_should_send = 1;		

			gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		}
		break;

	default :
		multi_common_add_notify(XSTR("Not implemented yet!",760));
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		break;
	}
}

// display all relevant info for active games
void multi_join_display_games()
{		
	if(!Active_games.empty()){

		int count = 0;
		int y_start = Mj_list_y[gr_screen.res];
		int line_height = gr_get_font_height() + 1;

		for (auto game = Active_games.begin(); game != Active_games.end(); ++game) {
			// stop displaying if we are going to overrun the container
			if (count >= Mj_max_game_items[gr_screen.res]) {
				break;
			}
			// blit the game status (including text and type icon)
			multi_join_blit_game_status(&(*game),y_start);			
			
			SCP_string speed_text;
			int con_type;
			multi_join_game_set_speed_text(&(*game), con_type, speed_text);
			gr_set_color_fast(Multi_join_speed_colors[con_type]);
			gr_string(Mj_speed_coords[gr_screen.res][MJ_X_COORD], y_start, speed_text.c_str(), GR_RESIZE_MENU);

			bool selected = (count == Multi_join_list_selected ? true : false);

			// we'll want to have different colors for highlighted items, etc.
			if(selected){
				gr_set_color_fast(&Color_text_selected);
			} else {
				gr_set_color_fast(&Color_text_normal);
			}

			// display the game name, adding appropriate status chars
			char str[200];
			str[0] = '\0';
			if (game->flags & AG_FLAG_STANDALONE) {
				strcat_s(str,MJ_CHAR_STANDALONE);
			}
			if (game->flags & AG_FLAG_CAMPAIGN) {
				strcat_s(str,MJ_CHAR_CAMPAIGN);
			}

			// tack on the actual server name			
			strcat_s(str," ");
			strcat_s(str, game->name);
			if (game->mission_name[0] != '\0') {
				strcat_s(str, " / ");
				strcat_s(str, game->mission_name);
			} 

			// make sure the string fits in the display area and draw it
			font::force_fit_string(str, 199, Mj_game_name_coords[gr_screen.res][MJ_W_COORD]);
			gr_string(Mj_game_name_coords[gr_screen.res][MJ_X_COORD],y_start,str,GR_RESIZE_MENU);

			// display the ping time
			if (game->ping.ping_avg > 0) {
				if (game->ping.ping_avg > MULTI_PING_MIN_ONE_SECOND) {
					gr_set_color_fast(&Color_bright_red);
					strcpy_s(str,XSTR("> 1 sec",761));
				} else {
					// set the appropriate ping time color indicator
					if (game->ping.ping_avg > MULTI_PING_MIN_RED) {
						gr_set_color_fast(&Color_bright_red);
					} else if (game->ping.ping_avg > MULTI_PING_MIN_ORANGE) {
						gr_set_color_fast(&Color_orange);
					} else if (game->ping.ping_avg > MULTI_PING_MIN_YELLOW) {
						gr_set_color_fast(&Color_bright_yellow);
					} else {
						gr_set_color_fast(&Color_bright_green);
					}

					sprintf(str, "%d", game->ping.ping_avg);
					strcat_s(str,XSTR(" ms",762));  // [[ Milliseconds ]]
				}

				gr_string(Mj_ping_coords[gr_screen.res][MJ_X_COORD],y_start,str,GR_RESIZE_MENU);
			}

			// display the number of players (be sure to center it)
			if (selected) {
				gr_set_color_fast(&Color_text_selected);
			} else {
				gr_set_color_fast(&Color_text_normal);
			}
			sprintf(str, "%d", game->num_players);

			int w, h;
			gr_get_string_size(&w,&h,str);
			gr_string(Mj_players_coords[gr_screen.res][MJ_X_COORD] + (Mj_players_coords[gr_screen.res][MJ_W_COORD] - w)/2,y_start,str,GR_RESIZE_MENU);			

			count++;
			y_start += line_height;
		}
	}
	// if there are no items on the list, display this info
	else {
		gr_set_color_fast(&Color_bright);
		gr_string(Mj_game_name_coords[gr_screen.res][MJ_X_COORD] - 30,Mj_list_y[gr_screen.res],XSTR("<No game servers found>",763),GR_RESIZE_MENU);
	}
}

void multi_join_game_set_speed_text(active_game* game, int& con_type, SCP_string& speed_text)
{
	// get the connection type
	con_type = (game->flags & AG_FLAG_CONNECTION_SPEED_MASK) >> AG_FLAG_CONNECTION_BIT;
	if ((con_type > 4) || (con_type < 0)) {
		con_type = 0;
	}

	speed_text = Multi_join_speed_labels[con_type];
}

void multi_join_game_set_status_text(active_game* game, SCP_string& status_text)
{
	switch (game->flags & AG_FLAG_STATE_MASK) {
	case AG_FLAG_FORMING:
		status_text = XSTR("Forming", 764);
		break;
	case AG_FLAG_BRIEFING:
		status_text = XSTR("Briefing", 765);
		break;
	case AG_FLAG_DEBRIEF:
		status_text = XSTR("Debrief", 766);
		break;
	case AG_FLAG_PAUSE:
		status_text = XSTR("Paused", 767);
		break;
	case AG_FLAG_IN_MISSION:
		status_text = XSTR("Playing", 768);
		break;
	default:
		status_text = XSTR("Unknown", 769);
		break;
	}
}

void multi_join_blit_game_status(active_game *game, int y)
{
	int draw,str_w;
	SCP_string status_text;

	// blit the proper icon
	draw = 0;	
	switch( game->flags & AG_FLAG_TYPE_MASK ){
	// coop game
	case AG_FLAG_COOP:
		if(Multi_common_icons[MICON_COOP] != -1){
			gr_set_bitmap(Multi_common_icons[MICON_COOP]);		
			draw = 1;
		}
		break;	
	
	// team vs. team game
	case AG_FLAG_TEAMS:
		if(Multi_common_icons[MICON_TVT] != -1){
			gr_set_bitmap(Multi_common_icons[MICON_TVT]);
			draw = 1;
		} 
		break;	

	// dogfight game
	case AG_FLAG_DOGFIGHT:
		if(Multi_common_icons[MICON_DOGFIGHT] != -1){
			gr_set_bitmap(Multi_common_icons[MICON_DOGFIGHT]);
			draw = 1;
		} 
		break;	
	}
	// if we're supposed to draw a bitmap
	if(draw){
		gr_bitmap(Mj_game_icon_coords[gr_screen.res][MJ_X_COORD],y-1,GR_RESIZE_MENU);
	}

	multi_join_game_set_status_text(game, status_text);
	
	//Set the color
	switch (game->flags & AG_FLAG_STATE_MASK) {
	case AG_FLAG_FORMING:
		gr_set_color_fast(&Color_bright_green);
		break;
	case AG_FLAG_BRIEFING:
	case AG_FLAG_DEBRIEF:
	case AG_FLAG_PAUSE:
	case AG_FLAG_IN_MISSION:
		gr_set_color_fast(&Color_bright_red);
		break;
	default:
		gr_set_color_fast(&Color_bright);
		break;
	}
	
	gr_get_string_size(&str_w,NULL,status_text.c_str());
	gr_string(Mj_status_coords[gr_screen.res][MJ_X_COORD] + ((Mj_status_coords[gr_screen.res][MJ_W_COORD] - str_w)/2),y,status_text.c_str(),GR_RESIZE_MENU);
}

void multi_join_read_ip_address_file(SCP_list<SCP_string>& list)
{
	char line[IP_STRING_LEN];
	CFILE* file = NULL;

	// attempt to open the ip list file
	file = cfopen(IP_CONFIG_FNAME, "rt", CF_TYPE_DATA);
	if (file == NULL) {
		nprintf(("Network", "Error loading tcp.cfg file!\n"));
		return;
	}

	// read in all the strings in the file
	while (!cfeof(file)) {
		line[0] = '\0';
		cfgets(line, IP_STRING_LEN, file);

		// strip off any newline character
		if (line[strlen(line) - 1] == '\n') {
			line[strlen(line) - 1] = '\0';
		}

		// 0 length lines don't get processed
		if ((line[0] == '\0') || (line[0] == '\n'))
			continue;

		if (!psnet_is_valid_ip_string(line)) {
			nprintf(("Network", "Invalid ip string (%s)\n", line));
		} else {
			if (list.size() < MAX_IP_ADDRS - 1) {
				list.push_back(line);
			}
		}
	}

	cfclose(file);
}

bool multi_join_write_ip_address_file(SCP_list<SCP_string>& list)
{
	CFILE* file = NULL;

	// attempt to open the ip list file for writing
	file = cfopen(IP_CONFIG_FNAME, "wt", CF_TYPE_DATA);
	if (file == NULL) {
		nprintf(("Network", "Error loading tcp.cfg file\n"));
		return false;
	}

	for (auto ip : list) {
		if (!psnet_is_valid_ip_string(ip.c_str())) {
			nprintf(("Network", "Invalid ip string (%s)\n", ip.c_str()));
		} else {
			cfputs(ip.c_str(), file);

			// make sure to tack on a newline if necessary
			if (ip[strlen(&ip[0]) - 1] != '\n') {
				cfputs(NOX("\n"), file);
			}
		}
	}

	cfclose(file);

	return true;
}

void multi_join_load_tcp_addrs()
{
	net_addr addr;	
	server_item *item;

	// free up any existing server list
	multi_free_server_list();

	SCP_list<SCP_string> list;
	multi_join_read_ip_address_file(list);

	for (auto const& ip : list) {
		if (!psnet_string_to_addr(ip.c_str(), &addr)) {
			continue;
		}

		if (addr.port == 0) {
			addr.port = DEFAULT_GAME_PORT;
		}

		// create a new server item on the list
		item = multi_new_server_item();

		if (item != nullptr) {
			memcpy(&item->server_addr, &addr, sizeof(item->server_addr));
		}
	}
}

// do stuff like pinging servers, sending out requests, etc
void multi_join_do_netstuff()
{
	// handle game query stuff
	if ( !Multi_join_glr_stamp.isValid() ) {
		broadcast_game_query();

		if ( !MULTI_IS_TRACKER_GAME && (Net_player->p_info.options.flags & MLO_FLAG_LOCAL_BROADCAST) ) {
			Multi_join_glr_stamp = ui_timestamp(MULTI_JOIN_REFRESH_TIME_LOCAL);
		} else {
			Multi_join_glr_stamp = ui_timestamp(MULTI_JOIN_REFRESH_TIME);
		}
	} 
	// otherwise send out game query and restamp
	else if ( ui_timestamp_elapsed(Multi_join_glr_stamp) ) {
		broadcast_game_query();

		if ( !MULTI_IS_TRACKER_GAME && (Net_player->p_info.options.flags & MLO_FLAG_LOCAL_BROADCAST) ) {
			Multi_join_glr_stamp = ui_timestamp(MULTI_JOIN_REFRESH_TIME_LOCAL);
		} else {
			Multi_join_glr_stamp = ui_timestamp(MULTI_JOIN_REFRESH_TIME);
		}		
	}

	// if we're doing local broadcast then check broadcast queries
	if ( !MULTI_IS_TRACKER_GAME && (Net_player->p_info.options.flags & MLO_FLAG_LOCAL_BROADCAST) ) {
		multi_mdns_query_do();
	}

	// check to see if we've been accepted.  If so, put up message saying so
	if ( Net_player->flags & (NETINFO_FLAG_ACCEPT_INGAME|NETINFO_FLAG_ACCEPT_CLIENT|NETINFO_FLAG_ACCEPT_HOST|NETINFO_FLAG_ACCEPT_OBSERVER) ) {
		multi_common_add_notify(XSTR("Accepted.  Waiting for player data.",770));
	}

	// check to see if any join packets we have sent have timed out
	if (Multi_join_sent_stamp.isValid() && ui_timestamp_elapsed(Multi_join_sent_stamp)) {
		Multi_join_sent_stamp = UI_TIMESTAMP::invalid();
		multi_common_add_notify(XSTR("Join request timed out!",771));
	}

	// check to see if we should be pinging everyone
	if ( !Multi_join_ping_stamp.isValid() || ui_timestamp_elapsed(Multi_join_ping_stamp) ) {
		multi_join_ping_all();
		Multi_join_ping_stamp = ui_timestamp(MULTI_JOIN_PING_TIME);
	} 

	// cull timeouts
	multi_join_cull_timeouts();
}

// evaluate a returned pong.
void multi_join_eval_pong(net_addr *addr, fix pong_time)
{	
	if(!Active_games.empty()){
		for (auto game = Active_games.begin(); game != Active_games.end(); ++game) {
			if(psnet_same(&game->server_addr,addr)){
				multi_ping_eval_pong(&game->ping, pong_time);
				
				break;
			}
		}
	}	
}

// ping all the server on the list
void multi_join_ping_all()
{
	if(!Active_games.empty()){
		for (auto game = Active_games.begin(); game != Active_games.end(); ++game) {
			send_server_query(&game->server_addr);
			multi_ping_send(&game->server_addr, &game->ping);
		}
	}
}

void multi_join_process_select()
{
	int line_height = gr_get_font_height() + 1;

	// if we don't have anything selected and there are items on the list - select the first one
	if((Multi_join_list_selected == -1) && !Active_games.empty()){
		Multi_join_list_selected = 0;
		Multi_join_selected_item = multi_join_get_game(0);				
		Multi_join_list_start = 0;

		// send a mission description request to this guy		
		send_netgame_descript_packet(&Multi_join_selected_item->server_addr,0);
		multi_common_set_text("");

		// I sure hope this doesn't happen
		Assertion(Multi_join_selected_item != nullptr, "Tried to join a null multi game. Please report!");
		return;
	} 
	// otherwise see if he's clicked on an item
	else if(Multi_join_select_button.pressed() && !Active_games.empty()){		 
		int y,item;		
		Multi_join_select_button.get_mouse_pos(NULL,&y);
		item = y / line_height;
		if (item + Multi_join_list_start < static_cast<int>(Active_games.size())) {		
			gamesnd_play_iface(InterfaceSounds::IFACE_MOUSE_CLICK);

			Multi_join_list_selected = item + Multi_join_list_start;
			Multi_join_selected_item = multi_join_get_game(Multi_join_list_selected);
			
			// I sure hope this doesn't happen
			Assertion(Multi_join_selected_item != nullptr, "Tried to join a null multi game. Please report!");

			// send a mission description request to this guy
			send_netgame_descript_packet(&Multi_join_selected_item->server_addr,0);
			multi_common_set_text("");			
		}		
	}

	// if he's double clicked, then select it and accept		
	if(Multi_join_select_button.double_clicked()){			
		int y,item;		
		Multi_join_select_button.get_mouse_pos(NULL,&y);
		item = y / line_height;
		if(item == Multi_join_list_selected){		
			multi_join_button_pressed(MJ_ACCEPT);
		}
	}
}

// maybe update selected game's description
void multi_join_maybe_update_selected(active_game *game)
{
	if ( !game || !Multi_join_selected_item ) {
		return;
	}

	// if not our selected game, bail
	if( !psnet_same(&Multi_join_selected_item->server_addr, &game->server_addr) ) {
		return;
	}

	// if the mission hasn't changed, bail
	if ( !strcmp(Multi_join_selected_item->mission_name, game->mission_name) ) {
		return;
	}

	// send a mission description request to this guy
	send_netgame_descript_packet(&Multi_join_selected_item->server_addr, 0);
}

// return game n (0 based index)
active_game *multi_join_get_game(int n)
{
	if(!Active_games.empty()){
		SCP_list<active_game>::iterator game = Active_games.begin();
		std::advance(game, n);
		return &(*game);
	}
	nprintf(("Network", "Warning, couldn't find game item %d!\n", n));
	return nullptr;
}

// scroll through the game list
void multi_join_list_scroll_up()
{
	// if we're not at the beginning of the list, scroll up	
	if(Multi_join_list_start != 0){
		Multi_join_list_start--;		

		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}
}

// scroll through the game list
void multi_join_list_scroll_down()
{
	if((static_cast<int>(Active_games.size()) - Multi_join_list_start) > Mj_max_game_items[gr_screen.res]){
		Multi_join_list_start++;		

		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}
}

void multi_join_list_page_up()
{
	// in this case, just set us to the beginning of the list
	if((Multi_join_list_start - Mj_max_game_items[gr_screen.res]) < 0){
		Multi_join_list_start = 0;	

		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		// otherwise page the whole thing up
		int idx;
		for(idx=0; idx<Mj_max_game_items[gr_screen.res]; idx++){
			Multi_join_list_start--;		
		}
		gamesnd_play_iface(InterfaceSounds::SCROLL);
	}
}

void multi_join_list_page_down()
{	
	int count = 0;

	// page the whole thing down		
	while((count < Mj_max_game_items[gr_screen.res]) && ((static_cast<int>(Active_games.size()) - Multi_join_list_start) > Mj_max_game_items[gr_screen.res])){
		Multi_join_list_start++;

		// next 
		count++;
	}	
	gamesnd_play_iface(InterfaceSounds::SCROLL);
}

void multi_join_cull_timeouts()
{
	if (Active_games.empty()) {
		return;
	}

	// traverse through the entire list if any items exist
	int i = 0;
	for (auto game = Active_games.begin(); game != Active_games.end(); ) {
		if (game->heard_from_timer.isValid() && (ui_timestamp_elapsed(game->heard_from_timer))) {

			// handle any gui details related to deleting this item
			multi_join_handle_item_cull(i);

			// this list may have been cleared so check for it
			if (Active_games.empty()) {
				break;
			}

			// delete the item
			game = Active_games.erase(game);
		} else {
			++i;
			++game;
		}
	}
}

// deep magic begins here. 
void multi_join_handle_item_cull(int item_index)
{	
	Assertion((item_index >= 0) && (item_index < static_cast<int>(Active_games.size())),
		"Tried to cull a multiplayer game that doesn't exist! Please report!");

	// if this is the only item on the list, unset everything
	if(Active_games.size() == 1){
		Multi_join_list_selected = -1;
		Multi_join_selected_item = nullptr;
		
		Multi_join_slider.set_numberItems(0);
		Multi_join_list_start = -1;

		Active_games.clear();

		// return
		return;
	}	
	
	// see if we should be adjusting our currently selected item
	if(item_index <= Multi_join_list_selected){
		// the selected item is the head of the list
		if (Multi_join_list_selected == 0) {
			// move the pointer up since this item is about to be destroyed
			Multi_join_list_selected++;
		} else {			
			Multi_join_list_selected--;
		}
	}

	Multi_join_selected_item = multi_join_get_game(Multi_join_list_selected);
	
	// see if we should be adjusting out current start position
	if(item_index <= Multi_join_list_start){
		// the start position is the head of the list
		if(Multi_join_list_start == 0){
			// move the pointer up since this item is about to be destroyed
			Multi_join_list_start++;
		} else {
			// if this is the item being deleted, select the previous one
			Multi_join_list_start--;
		}
	}

	// maybe go back up a bit so that we always have a full page of items	
	if(static_cast<int>(Active_games.size()) > Mj_max_game_items[gr_screen.res]){
		while ((static_cast<int>(Active_games.size()) - Multi_join_list_start) < Mj_max_game_items[gr_screen.res]) {
			Multi_join_list_start--;
		}
	}	

	// set slider location
	Multi_join_slider.set_numberItems(static_cast<int>(Active_games.size()) > Mj_max_game_items[gr_screen.res] ? static_cast<int>(Active_games.size()) - Mj_max_game_items[gr_screen.res] : 0);
	Multi_join_slider.force_currentItem(Multi_join_list_start);	
}

void multi_join_send_join_request(int as_observer)
{	
	// don't do anything if we have no items selected
	if(Multi_join_selected_item == nullptr){
		return;
	}

	// 5/26/98 -- for team v team games, don't allow ingame joining :-(
//	if ( (Multi_join_selected_item->flags & AG_FLAG_TEAMS) && (Multi_join_selected_item->flags & (AG_FLAG_PAUSE|AG_FLAG_IN_MISSION)) ) {
//		popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("Joining ingame is currently not allowed for team vs. team games",772));
//		return;
//	}

	memset(&Multi_join_request,0,sizeof(join_request));

	// if the netgame is in password mode, put up a request for the password
	if(Multi_join_selected_item->flags & AG_FLAG_PASSWD){
		if(!multi_passwd_popup(Multi_join_request.passwd)){
			return;
		}

		nprintf(("Network", "Password : %s\n", Multi_join_request.passwd));
	}	
		
	// fill out the join request struct	
	strcpy_s(Multi_join_request.callsign,Player->callsign);
	if(Player->image_filename[0] != '\0'){
		strcpy_s(Multi_join_request.image_filename, Player->image_filename);
	}	
	if(Player->m_squad_filename[0] != '\0'){
		strcpy_s(Multi_join_request.squad_filename, Player->m_squad_filename);
	}

	// tracker id (if any)
	Multi_join_request.tracker_id = Multi_tracker_id;

	// player's rank (at least, what he wants you to _believe_)
	Multi_join_request.player_rank = (ubyte)Player->stats.rank;
	
	// misc join flags
	Multi_join_request.flags = 0;
	if(as_observer){
		Multi_join_request.flags |= JOIN_FLAG_AS_OBSERVER;
	}	

	// if the player has hacked data
	if(game_hacked_data()){
		Multi_join_request.flags |= JOIN_FLAG_HAXOR;
	}
	
	// pxo squad info
	strcpy_s(Multi_join_request.pxo_squad_name, Multi_tracker_squad_name);

	// version of this server
	Multi_join_request.version = MULTI_FS_SERVER_VERSION;

	// server compatible version
	Multi_join_request.comp_version = MULTI_FS_SERVER_COMPATIBLE_VERSION;

	// his local player options
	memcpy(&Multi_join_request.player_options,&Player->m_local_options,sizeof(multi_local_options));
			
	// set the server address for the netgame
	memcpy(&Netgame.server_addr, &Multi_join_selected_item->server_addr, sizeof(Netgame.server_addr));

	// send a join request to the guy
	send_join_packet(&Multi_join_selected_item->server_addr,&Multi_join_request);

   // now we wait
	Multi_join_sent_stamp = ui_timestamp(MULTI_JOIN_SENT_WAIT);

	psnet_flush();
	multi_common_add_notify(XSTR("Sending join request...",773));
}

void multi_join_create_game()
{
	// maybe warn the player about possible crappy server conditions
	if(!multi_join_maybe_warn()){
		return;
	}

	// make sure to flag ourself as being the master
	Net_player->flags |= (NETINFO_FLAG_AM_MASTER | NETINFO_FLAG_GAME_HOST);
	Net_player->state = NETPLAYER_STATE_HOST_SETUP;	

	// if we're in PXO mode, mark it down in our player struct
	if(MULTI_IS_TRACKER_GAME){
		Player->flags |= PLAYER_FLAGS_HAS_PLAYED_PXO;
		Player->save_flags |= PLAYER_FLAGS_HAS_PLAYED_PXO;
	} 
	// otherwise, if he's already played PXO games, warn him
	else {
		
		if(Player->flags & PLAYER_FLAGS_HAS_PLAYED_PXO){
			if(!multi_join_warn_pxo()){
				return;
			}			
		}
		
	}

	gameseq_post_event(GS_EVENT_MULTI_START_GAME);
	gamesnd_play_iface(InterfaceSounds::USER_SELECT);
}

void multi_join_reset_join_stamp()
{
	// unset the timestamp here so the user can immediately send another join request
	Multi_join_sent_stamp = UI_TIMESTAMP::invalid();
	multi_common_add_notify("");
}

#define CW_CODE_CANCEL				0				// cancel the action
#define CW_CODE_OK					1				// continue anyway
#define CW_CODE_INFO					2				// gimme some more information

#define LOW_WARN_TEXT				XSTR("Warning - You have low object updates selected. A server with low object updates will not be able to handle more than 1 client without performance problems",775)
#define LOW_INFO_TEXT				XSTR("Low update level caps all bandwidth at ~2000 bytes/second. It is appropriate for clients with 28.8 modems, but is not reccomended for servers. In addition, any clients connecting to this server should use low object updates as well. To change your settings go to the options menu (f2), and select the Multi button",776)

#define MED_WARN_TEXT				XSTR("Warning - You have medium object updates selected. A server with medium object updates will not be able to handle more than 1 or 2 clients without performance problems",777)
#define MED_INFO_TEXT				XSTR("Medium update level caps all bandwidth at ~4000 bytes/second. It is appropriate for clients with 56.6 modems, but is not reccomended for servers. In addition, any clients connecting to this server should use low object updates as well. To change your settings go to the options menu (f2), and select the Multi button",778)

int multi_join_warn_update_low(int code)
{
	switch(code){
	case CW_CODE_OK:
		return popup(0,3,XSTR("&Cancel",779),XSTR("&Continue",780),XSTR("&More info",781),LOW_WARN_TEXT);

	case CW_CODE_INFO:
		return popup(0,3,XSTR("&Cancel",779),XSTR("&Continue",780),XSTR("&More info",781),LOW_INFO_TEXT);
	}

	return CW_CODE_CANCEL;
}

int multi_join_warn_update_medium(int code)
{
	switch(code){
	case CW_CODE_OK:
		return popup(0,3,XSTR("&Cancel",779),XSTR("&Continue",780),XSTR("&More info",781),MED_WARN_TEXT);

	case CW_CODE_INFO:
		return popup(0,3,XSTR("&Cancel",779),XSTR("&Continue",780),XSTR("&More info",781),MED_INFO_TEXT);
	}

	return CW_CODE_CANCEL;
}

int multi_join_maybe_warn()
{
	int code;

	// if the player is set for low updates
	if(Player->m_local_options.obj_update_level == OBJ_UPDATE_LOW){
		code = CW_CODE_OK;
		do {
			code = multi_join_warn_update_low(code);
		} while((code != CW_CODE_CANCEL) && (code != CW_CODE_OK));
		
		return code;
	}
	
	// if the player is set for medium updates
	else if(Player->m_local_options.obj_update_level == OBJ_UPDATE_MEDIUM){
		code = CW_CODE_OK;
		do {
			code = multi_join_warn_update_medium(code);
		} while((code != CW_CODE_CANCEL) && (code != CW_CODE_OK));
		
		return code;
	} 
	
	return 1;
}

int multi_join_warn_pxo()
{
	return popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON | PF_TITLE_BIG | PF_TITLE_RED, 2, XSTR("&Back", 995), XSTR("&Continue",780), XSTR("Warning\n\nThis pilot has played PXO games. If you continue and play a non-PXO game, your stats will not be updated", 1006)) <= 0 ? 0 : 1;
	//return 1;
}

void multi_join_blit_protocol()
{
	gr_set_color_fast(&Color_bright);
	gr_string(5, 2, "TCP", GR_RESIZE_MENU);
}


// -------------------------------------------------------------------------------------------------
//
// MULTIPLAYER START GAME screen
//

//XSTR:OFF
// bitmap defs
#define MULTI_SG_PALETTE			"InterfacePalette"

static const char *Multi_sg_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiStartGame",			// GR_640
	"2_MultiStartGame"			// GR_1024
};

static const char *Multi_sg_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiStartGame-M",			// GR_640
	"2_MultiStartGame-M"			// GR_1024
};

//XSTR:ON

int Multi_sg_rank_max_display[GR_NUM_RESOLUTIONS] = {
	2,		// GR_640
	4		// GR_1024
};

// constants for coordinate look ups
#define MSG_X_COORD 0
#define MSG_Y_COORD 1
#define MSG_W_COORD 2
#define MSG_H_COORD 3

// area definitions

// input password field
int Msg_passwd_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		36, 236, 408, 20
	},
	{ // GR_1024
		58, 377, 652, 32
	}
};

// input game title field
int Msg_title_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		29, 49, 415, 23
	},
	{ // GR_1024
		46, 78, 664, 36
	}
};

// rank selected field
int Msg_rank_sel_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		242, 254, 126, 12
	},
	{ // GR_1024
		242, 254, 126, 12
	}
};

// rank list field
int Msg_rank_list_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		37, 297, 131, 16
	},
	{ // GR_1024
		60, 469, 652, 32
	}
};


// button defs
#define MULTI_SG_NUM_BUTTONS	10
//#define MULTI_SG_NUM_BUTTONS	12

#define MSG_OPEN_GAME			0
//#define MSG_CLOSED_GAME			1
//#define MSG_RESTRICTED_GAME		2
#define MSG_PASSWD_GAME			1
#define MSG_RANK_SET_GAME		2
#define MSG_RANK_SCROLL_UP		3
#define MSG_RANK_SCROLL_DOWN	4
#define MSG_RANK_ABOVE			5
#define MSG_RANK_BELOW			6
#define MSG_HELP				7
#define MSG_OPTIONS				8
#define MSG_ACCEPT				9

UI_WINDOW Multi_sg_window;												// the window object for the join screen
UI_BUTTON Multi_sg_rank_button;										// for selecting the rank marker
UI_INPUTBOX	Multi_sg_game_name;										// for Netgame.name
UI_INPUTBOX Multi_sg_game_passwd;									// for Netgame.passwd
int Multi_sg_bitmap;														// the background bitmap

ui_button_info Multi_sg_buttons[GR_NUM_RESOLUTIONS][MULTI_SG_NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info("MSG_00",	1,		184,	34,	191,	2),		// open
//******ui_button_info("MSG_01",	1,		159,	34,	166,	1),		// closed
//******ui_button_info("MSG_02",	1,		184,	34,	191,	2),		// restricted
		ui_button_info("MSG_03",	1,		209,	34,	218,	3),		// password
		ui_button_info("MSG_04",	1,		257,	34,	266,	4),		// rank set
		ui_button_info("MSG_05",	1,		282,	-1,	-1,	5),		// rank scroll up
		ui_button_info("MSG_06",	1,		307,	-1,	-1,	6),		// rank scroll down
		ui_button_info("MSG_07",	177,	282,	210,	290,	7),		// rank above
		ui_button_info("MSG_08",	177,	307,	210,	315,	8),		// rank below
		ui_button_info("MSG_09",	536,	429,	500,	440,	9),		// help
		ui_button_info("MSG_10",	536,	454,	479,	464,	10),		// options
		ui_button_info("MSG_11",	576,	432,	571,	415,	11),		// accept
	},
	{ // GR_1024
		ui_button_info("2_MSG_00",	2,		295,	51,	307,	2),		// open
//******ui_button_info("2_MSG_01",	2,		254,	51,	267,	1),		// closed
//******ui_button_info("2_MSG_02",	2,		295,	51,	307,	2),		// restricted
		ui_button_info("2_MSG_03",	2,		335,	51,	350,	3),		// password
		ui_button_info("2_MSG_04",	2,		412,	51,	426,	4),		// rank set
		ui_button_info("2_MSG_05",	2,		452,	-1,	-1,	5),		// rank scroll up
		ui_button_info("2_MSG_06",	2,		492,	-1,	-1,	6),		// rank scroll down
		ui_button_info("2_MSG_07",	284,	452,	335,	465,	7),		// rank above
		ui_button_info("2_MSG_08",	284,	492,	335,	505,	8),		// rank below
		ui_button_info("2_MSG_09",	858,	687,	817,	706,	9),		// help
		ui_button_info("2_MSG_10",	858,	728,	797,	743,	10),		// options
		ui_button_info("2_MSG_11",	921,	692,	921,	664,	11),		// accept
	},
};

//#define MULTI_SG_NUM_TEXT			13
#define MULTI_SG_NUM_TEXT			11
UI_XSTR Multi_sg_text[GR_NUM_RESOLUTIONS][MULTI_SG_NUM_TEXT] = {
	{ // GR_640
		{"Open",					1322,		34,	191,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_OPEN_GAME].button},
//******{"Closed",				1323,		34,	166,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_CLOSED_GAME].button},
//******{"Restricted",			1324,		34,	191,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_RESTRICTED_GAME].button},
		{"Password Protected",	1325,	34,	218,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_PASSWD_GAME].button},
		{"Allow Rank",			1326,		34,	266,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_RANK_SET_GAME].button},
		{"Above",				1327,		210,	290,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_RANK_ABOVE].button},
		{"Below",				1328,		210,	315,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_RANK_BELOW].button},
		{"Help",					928,		500,	440,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_HELP].button},
		{"Options",				1036,		479,	464,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[0][MSG_OPTIONS].button},
		{"Accept",				1035,		571,	415,	UI_XSTR_COLOR_PINK,	-1,	&Multi_sg_buttons[0][MSG_ACCEPT].button},
		{"Start Game",			1329,		26,	10,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
		{"Title",				1330,		26,	31,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
		{"Game Type",			1331,		12,	165,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
	},
	{ // GR_1024
		{"Open",					1322,		51,	307,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_OPEN_GAME].button},
//******{"Closed",				1323,		51,	267,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_CLOSED_GAME].button},
//******{"Restricted",			1324,		51,	307,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_RESTRICTED_GAME].button},
		{"Password Protected",	1325,	51,	350,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_PASSWD_GAME].button},
		{"Allow Rank",			1326,		51,	426,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_RANK_SET_GAME].button},
		{"Above",				1327,		335,	465,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_RANK_ABOVE].button},
		{"Below",				1328,		335,	505,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_RANK_BELOW].button},
		{"Help",					928,		817,	706,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_HELP].button},
		{"Options",				1036,		797,	743,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_sg_buttons[1][MSG_OPTIONS].button},
		{"Accept",				1035,		921,	664,	UI_XSTR_COLOR_PINK,	-1,	&Multi_sg_buttons[1][MSG_ACCEPT].button},
		{"Start Game",			1329,		42,	22,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
		{"Title",				1330,		42,	50,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
		{"Game Type",			1331,		20,	264,	UI_XSTR_COLOR_GREEN,	-1,	NULL},
	}
};

// starting index for displaying ranks
int Multi_sg_rank_start;
int Multi_sg_rank_select;

// netgame pointer to indirect through
netgame_info *Multi_sg_netgame;

// hold temporary values in this structure when on a standalone server
netgame_info Multi_sg_netgame_temp;

int Multi_sg_overlay_id;

// forward declarations
void multi_sg_check_buttons();
void multi_sg_button_pressed(int n);
void multi_sg_init_gamenet();
void multi_sg_draw_radio_buttons();
void multi_sg_rank_scroll_up();
void multi_sg_rank_scroll_down();
void multi_sg_rank_display_stuff();
void multi_sg_rank_process_select();
void multi_sg_rank_build_name(const char *in,char *out);
void multi_sg_check_passwd();
void multi_sg_check_name();
void multi_sg_release_passwd();
int multi_sg_rank_select_valid(int rank);
void multi_sg_select_rank_default();

// function which takes a rank name and returns the index.  Useful for commandline options
// for above and below rank.  We return the index of the rank in the Ranks[] array.  If
// the rank isn't found, we return -1
int multi_start_game_rank_from_name( char *rank ) {
	int i;

	for ( i = 0; i < ((int)Ranks.size()); i++ ) {
		if ( !stricmp(Ranks[i].name, rank) ) {
			return i;
		}
	}

	return -1;
}

void multi_start_game_init(bool API_Access)
{
	int idx;

	// initialize the gamenet
	multi_sg_init_gamenet();
	
	if (!API_Access) {
		// create the interface window
		Multi_sg_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
		Multi_sg_window.set_mask_bmap(Multi_sg_bitmap_mask_fname[gr_screen.res]);

		// load the background bitmap
		Multi_sg_bitmap = bm_load(Multi_sg_bitmap_fname[gr_screen.res]);
		if (Multi_sg_bitmap < 0) {
			// we failed to load the bitmap - this is very bad
			Int3();
		}
	}
	
	// initialize the common notification messaging
	multi_common_notify_init();

	// initialize the common text area
	multi_common_set_text("");

	// use the common interface palette
	multi_common_set_palette();
	
	if (!API_Access) {
		// create the interface buttons
		for(idx=0; idx<MULTI_SG_NUM_BUTTONS; idx++){
			// create the object
			Multi_sg_buttons[gr_screen.res][idx].button.create(&Multi_sg_window, "", Multi_sg_buttons[gr_screen.res][idx].x, Multi_sg_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

			// set the sound to play when highlighted
			Multi_sg_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

			// set the ani for the button
			Multi_sg_buttons[gr_screen.res][idx].button.set_bmaps(Multi_sg_buttons[gr_screen.res][idx].filename);

			// set the hotspot
			Multi_sg_buttons[gr_screen.res][idx].button.link_hotspot(Multi_sg_buttons[gr_screen.res][idx].hotspot);
		}	

		// add all xstrs
		for(idx=0; idx<MULTI_SG_NUM_TEXT; idx++){
			Multi_sg_window.add_XSTR(&Multi_sg_text[gr_screen.res][idx]);
		}

		// load the help overlay
		Multi_sg_overlay_id = help_overlay_get_index(MULTI_START_OVERLAY);
		help_overlay_set_state(Multi_sg_overlay_id,gr_screen.res,0);
	}

	// intiialize the rank selection items	
	multi_sg_select_rank_default();	
	Multi_sg_rank_start = Multi_sg_rank_select;

	if (!API_Access) {
		// create the rank select button
		Multi_sg_rank_button.create(&Multi_sg_window,"",Msg_rank_list_coords[gr_screen.res][MSG_X_COORD],Msg_rank_list_coords[gr_screen.res][MSG_Y_COORD],Msg_rank_list_coords[gr_screen.res][MSG_W_COORD],Msg_rank_list_coords[gr_screen.res][MSG_H_COORD],0,1);	
		Multi_sg_rank_button.hide();		

		// create the netgame name input box
		Multi_sg_game_name.create(&Multi_sg_window,Msg_title_coords[gr_screen.res][MSG_X_COORD],Msg_title_coords[gr_screen.res][MSG_Y_COORD],Msg_title_coords[gr_screen.res][MSG_W_COORD],MAX_GAMENAME_LEN,"",UI_INPUTBOX_FLAG_ESC_CLR | UI_INPUTBOX_FLAG_INVIS,-1,&Color_normal);

		// create the netgame password input box, and disable it by default
		Multi_sg_game_passwd.create(&Multi_sg_window,Msg_passwd_coords[gr_screen.res][MSG_X_COORD],Msg_passwd_coords[gr_screen.res][MSG_Y_COORD],Msg_passwd_coords[gr_screen.res][MSG_W_COORD],16,"",UI_INPUTBOX_FLAG_ESC_CLR | UI_INPUTBOX_FLAG_PASSWD | UI_INPUTBOX_FLAG_INVIS,-1,&Color_normal);
		Multi_sg_game_passwd.hide();
		Multi_sg_game_passwd.disable();

		// set the netgame text to this gadget and make it have focus
		Multi_sg_game_name.set_text(Multi_sg_netgame->name);
		Multi_sg_game_name.set_focus();	
	}

	// if starting a netgame, set the name of the game and any other options that are appropriate
	if ( Cmdline_start_netgame ) {
		if ( Cmdline_game_name != NULL ) {
			strcpy_s( Multi_sg_netgame->name, Cmdline_game_name );
			if (!API_Access) {
				Multi_sg_game_name.set_text(Multi_sg_netgame->name);
			}
		}

		// deal with the different game types -- only one should even be active, so we will just go down
		// the line.  Last one wins.
		if ( Cmdline_closed_game ) {
			Multi_sg_netgame->mode = NG_MODE_CLOSED;
		} else if ( Cmdline_restricted_game ) {
			Multi_sg_netgame->mode = NG_MODE_RESTRICTED;
		} else if ( Cmdline_game_password != NULL ) {
			Multi_sg_netgame->mode = NG_MODE_PASSWORD;
			strcpy_s(Multi_sg_netgame->passwd, Cmdline_game_password);
			if (!API_Access) {
				Multi_sg_game_passwd.set_text(Multi_sg_netgame->passwd);
			}
		}

		// deal with rank above and rank below
		if ( (Cmdline_rank_above != NULL) || (Cmdline_rank_below != NULL) ) {
			int rank;
			char *rank_str;

			if ( Cmdline_rank_above != NULL ) {
				rank_str = Cmdline_rank_above;
			} else {
				rank_str = Cmdline_rank_below;
			}

			// try and get the rank index from the name -- if found, then set the rank base
			// and the game type.  apparently we only support either above or below, not both
			// together, so I make a random choice
			rank = multi_start_game_rank_from_name( rank_str );
			if ( rank != -1 ) {
				Multi_sg_netgame->rank_base = Multi_sg_rank_select;

				// now an arbitrary decision
				if ( Cmdline_rank_above != NULL ) {
					Multi_sg_netgame->mode = NG_MODE_RANK_ABOVE;
				} else {
					Multi_sg_netgame->mode = NG_MODE_RANK_BELOW;
				}
			}
		}

		gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
	}
}

void multi_start_game_do(bool API_Access)
{
	// return here since we will be moving to the next stage anyway -- I don't want to see the backgrounds of
	// all the screens for < 1 second for every screen we automatically move to.
	if ( Cmdline_start_netgame ) {
		Cmdline_start_netgame = 0; // DTP no quit fix; by using -startgame Quit was sort of out of function 
		return;
	}

	if (!API_Access) {
		int k = Multi_sg_window.process();

		// process any keypresses
		switch (k) {
		case KEY_ESC:
			if (help_overlay_active(Multi_sg_overlay_id)) {
				help_overlay_set_state(Multi_sg_overlay_id, gr_screen.res, 0);
			} else {
				gamesnd_play_iface(InterfaceSounds::USER_SELECT);
				multi_quit_game(PROMPT_NONE);
			}
			break;

		// same as ACCEPT
		case KEY_LCTRL + KEY_ENTER:
		case KEY_RCTRL + KEY_ENTER:
			gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
			gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
			break;
		}

		if (mouse_down(MOUSE_LEFT_BUTTON)) {
			help_overlay_set_state(Multi_sg_overlay_id, gr_screen.res, 0);
		}

		// check to see if the user has selected a different rank
		multi_sg_rank_process_select();

		// check any button presses
		multi_sg_check_buttons();

		// check to see if any of the input boxes have changed, and update the appropriate Netgame fields if necessary
		multi_sg_check_passwd();
		multi_sg_check_name();

		// draw the background, etc
		gr_reset_clip();
		GR_MAYBE_CLEAR_RES(Multi_sg_bitmap);
		if (Multi_sg_bitmap != -1) {
			gr_set_bitmap(Multi_sg_bitmap);
			gr_bitmap(0, 0, GR_RESIZE_MENU);
		}
		Multi_sg_window.draw();

		// display rank stuff
		multi_sg_rank_display_stuff();
	}

	// display any pending notification messages
	multi_common_notify_do();

	if (!API_Access) {
		// draw all radio button
		multi_sg_draw_radio_buttons();

		// draw the help overlay
		help_overlay_maybe_blit(Multi_sg_overlay_id, gr_screen.res);

		// flip the buffer
		gr_flip();
	}
}

void multi_start_game_close(bool API_Access)
{
	// if i'm the host on a standalone server, send him my start game options (passwd, mode, etc)
	if((Net_player->flags & NETINFO_FLAG_GAME_HOST) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER)){
		multi_options_update_start_game(Multi_sg_netgame);
	}
	
	// unload any bitmaps
	if (!bm_unload(Multi_sg_bitmap)) {
		nprintf(
			("General", "WARNING : could not unload background bitmap %s\n", Multi_sg_bitmap_fname[gr_screen.res]));
	}

	if (!API_Access) {
		// destroy the UI_WINDOW
		Multi_sg_window.destroy();
	}
}

void multi_sg_check_buttons()
{
	int idx;
	for(idx=0;idx<MULTI_SG_NUM_BUTTONS;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_sg_buttons[gr_screen.res][idx].button.pressed()){
			multi_sg_button_pressed(idx);
			break;
		}
	}
}

void multi_sg_button_pressed(int n)
{
	switch(n){		
	// go to the options screen
	case MSG_OPTIONS:
		gameseq_post_event(GS_EVENT_OPTIONS_MENU);
		break;	

	// help overlay	
	case MSG_HELP:
		if(!help_overlay_active(Multi_sg_overlay_id)){
			help_overlay_set_state(Multi_sg_overlay_id,gr_screen.res,1);
		} else {
			help_overlay_set_state(Multi_sg_overlay_id,gr_screen.res,0);
		}
		break;

	// the open button was pressed
	case MSG_OPEN_GAME:		
		// if the closed option is selected
		if(Multi_sg_netgame->mode != NG_MODE_OPEN){
			Multi_sg_netgame->mode = NG_MODE_OPEN;

			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			
			// release the password control if necessary
			multi_sg_release_passwd();
		}
		// if its already selected
		else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

/*
	// the open button was pressed
	case MSG_CLOSED_GAME:		
		// if the closed option is selected
		if(Multi_sg_netgame->mode != NG_MODE_CLOSED){
			Multi_sg_netgame->mode = NG_MODE_CLOSED;

			gamesnd_play_iface(SND_USER_SELECT);
			
			// release the password control if necessary
			multi_sg_release_passwd();
		}
		// if its already selected
		else {
			gamesnd_play_iface(SND_GENERAL_FAIL);
		}
		break;
*/
	// toggle password protection
	case MSG_PASSWD_GAME:		
		// if we selected it
		if(Multi_sg_netgame->mode != NG_MODE_PASSWORD){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);

			Multi_sg_game_passwd.enable();			
			Multi_sg_game_passwd.unhide();
			Multi_sg_game_passwd.set_focus();

			Multi_sg_netgame->mode = NG_MODE_PASSWORD;			

			// copy in the current network password
			Multi_sg_game_passwd.set_text(Multi_sg_netgame->passwd);
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}			
		break;

/*
	// toggle "restricted" on or off
	case MSG_RESTRICTED_GAME:
		if(Multi_sg_netgame->mode != NG_MODE_RESTRICTED){
			gamesnd_play_iface(SND_USER_SELECT);
			Multi_sg_netgame->mode = NG_MODE_RESTRICTED;

			// release the password control if necessary
			multi_sg_release_passwd();
		} else {
			gamesnd_play_iface(SND_GENERAL_FAIL);
		}
		break;
*/
	// turn off all rank requirements
	case MSG_RANK_SET_GAME:		
		// if either is set, then turn then both off
		if((Multi_sg_netgame->mode != NG_MODE_RANK_BELOW) && (Multi_sg_netgame->mode != NG_MODE_RANK_ABOVE)){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);

			// set it to the default case if we're turning it off
			multi_sg_select_rank_default();
			Multi_sg_rank_start = Multi_sg_rank_select;			

			Multi_sg_netgame->mode = NG_MODE_RANK_ABOVE;

			// release the password control if necessary
			multi_sg_release_passwd();
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}		
		break;

	// rank above was pressed
	case MSG_RANK_ABOVE :
		if((Multi_sg_netgame->mode == NG_MODE_RANK_ABOVE) || (Multi_sg_netgame->mode == NG_MODE_RANK_BELOW)){
			Multi_sg_netgame->mode = NG_MODE_RANK_ABOVE;

			// select the first item
			multi_sg_select_rank_default();
			Multi_sg_rank_start = Multi_sg_rank_select;

			// play a sound
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// rank below was pressed
	case MSG_RANK_BELOW :
		if((Multi_sg_netgame->mode == NG_MODE_RANK_ABOVE) || (Multi_sg_netgame->mode == NG_MODE_RANK_BELOW)){
			Multi_sg_netgame->mode = NG_MODE_RANK_BELOW;
			
			// select the first item
			multi_sg_select_rank_default();
			Multi_sg_rank_start = Multi_sg_rank_select;			

			// play a sound
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}	
		break;

	// scroll the rank list up
	case MSG_RANK_SCROLL_UP:
		multi_sg_rank_scroll_up();
		break;

	// scroll the rank list down
	case MSG_RANK_SCROLL_DOWN:
		multi_sg_rank_scroll_down();
		break;

	// move to the create game screen
	case MSG_ACCEPT:
		gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		break;

	default :
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		multi_common_add_notify(XSTR("Not implemented yet!",760));		
		break;
	}
}

// NOTE : this is where all Netgame initialization should take place on the host
void multi_sg_init_gamenet()
{
	char buf[128],out_name[128];		
	net_addr save;
	net_player *server_save;	

	// back this data up in case we are already connected to a standalone
	memcpy(&save,&Netgame.server_addr,sizeof(net_addr));
	server_save = Netgame.server;

	// remove campaign flags
	Game_mode &= ~(GM_CAMPAIGN_MODE);

	// clear out the Netgame structure and start filling in the values
	Netgame.init();
	Multi_sg_netgame_temp.init();
	
	// if we're on the standalone, we're not the server, so we don't care about setting the netgame state
	if(Net_player->state != NETPLAYER_STATE_STD_HOST_SETUP){		
		Netgame.game_state = NETGAME_STATE_HOST_SETUP;
		Multi_sg_netgame = &Netgame;	

		// NETLOG
		ml_string(NOX("Starting netgame as Host/Server"));		
	} else {
		Multi_sg_netgame = &Multi_sg_netgame_temp;

		// NETLOG
		char server_addr[INET6_ADDRSTRLEN];
		psnet_addr_to_string(&Netgame.server_addr, server_addr, INET6_ADDRSTRLEN);

		ml_printf(NOX("Starting netgame as Host on Standalone server : %s"), (server_addr[0]) ? NOX("Unknown") : server_addr);
	}
	
	Net_player->tracker_player_id = Multi_tracker_id;

	Multi_sg_netgame->security = Random::next(1, 32766);			// get some random security number	
	Multi_sg_netgame->mode = NG_MODE_OPEN;
	Multi_sg_netgame->rank_base = 0;
	if(Multi_sg_netgame->security < 16){
		Multi_sg_netgame->security += 16;
	}

	// set the version_info field
	Multi_sg_netgame->version_info = NG_VERSION_ID;
	
	if(Net_player->flags & NETINFO_FLAG_GAME_HOST){
		Netgame.host = Net_player;
	}
	
	// set the default netgame flags
	Multi_sg_netgame->flags = 0;

	// intialize endgame stuff
	multi_endgame_init();

	// load in my netgame options
	multi_options_netgame_load(&Netgame.options);		

	// load my local netplayer options
	multi_options_local_load(&Net_player->p_info.options, Net_player);	
	
	// setup the default game name, taking care of string length and player callsigns
	memset(out_name,0,128);
	memset(buf,0,128);
	pilot_format_callsign_personal(Player->callsign,out_name);
	sprintf(buf, XSTR("%s game",782), out_name);  // [[ %s will be a pilot's name ]]
	if ( strlen(buf) > MAX_GAMENAME_LEN ){
		strcpy_s(buf, XSTR("Temporary name",783));
	}
	strcpy_s(Multi_sg_netgame->name, buf);

	// set the default qos and duration
	multi_voice_maybe_update_vars(Netgame.options.voice_qos,Netgame.options.voice_record_time);

	// make sure to set the server correctly (me or the standalone)
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){		
		memcpy(&Netgame.server_addr, &Psnet_my_addr,sizeof(net_addr));
		Netgame.server = Net_player;
		Net_player->player_id = multi_get_new_id();

		// setup debug flags
		Netgame.debug_flags = 0;
	} else {
		memcpy(&Netgame.server_addr,&save,sizeof(net_addr));
		Netgame.server = server_save;
	}

	// if I have hacked data
	if(game_hacked_data()){
		Net_player->flags |= NETINFO_FLAG_HAXOR;
	}

	// assign my player struct and other data	
	Net_player->flags |= (NETINFO_FLAG_CONNECTED | NETINFO_FLAG_DO_NETWORKING);
	Net_player->s_info.voice_token_timestamp = UI_TIMESTAMP::invalid();
	Net_player->s_info.player_collision_timestamp = TIMESTAMP::immediate();

	// if we're supposed to flush our cache directory, do so now
	if(Net_player->p_info.options.flags & MLO_FLAG_FLUSH_CACHE){
		multi_flush_multidata_cache();

		// NETLOG
		ml_string(NOX("Flushing multi-data cache"));
	}
			
	game_flush();
}

void multi_sg_draw_radio_buttons()
{
	// draw the appropriate radio button
	switch(Multi_sg_netgame->mode){
	case NG_MODE_OPEN:
		Multi_sg_buttons[gr_screen.res][MSG_OPEN_GAME].button.draw_forced(2);
		break;
/*
	case NG_MODE_CLOSED:
		Multi_sg_buttons[gr_screen.res][MSG_CLOSED_GAME].button.draw_forced(2);
		break;
*/	
	case NG_MODE_PASSWORD:
		Multi_sg_buttons[gr_screen.res][MSG_PASSWD_GAME].button.draw_forced(2);
		break;
/*
	case NG_MODE_RESTRICTED:
		Multi_sg_buttons[gr_screen.res][MSG_RESTRICTED_GAME].button.draw_forced(2);
		break;
*/
	case NG_MODE_RANK_ABOVE:
		Multi_sg_buttons[gr_screen.res][MSG_RANK_SET_GAME].button.draw_forced(2);
		Multi_sg_buttons[gr_screen.res][MSG_RANK_ABOVE].button.draw_forced(2);
		break;
	case NG_MODE_RANK_BELOW:
		Multi_sg_buttons[gr_screen.res][MSG_RANK_SET_GAME].button.draw_forced(2);
		Multi_sg_buttons[gr_screen.res][MSG_RANK_BELOW].button.draw_forced(2);
		break;
	}
}

void multi_sg_rank_scroll_up()
{	
	// if he doesn't have either of the rank flags set, then ignore this
	if((Multi_sg_netgame->mode != NG_MODE_RANK_ABOVE) && (Multi_sg_netgame->mode != NG_MODE_RANK_BELOW)){
		return;
	}

	if(Multi_sg_rank_start > 0){
		Multi_sg_rank_start--;
		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}
}

void multi_sg_rank_scroll_down()
{
	// if he doesn't have either of the rank flags set, then ignore this
	if((Multi_sg_netgame->mode != NG_MODE_RANK_ABOVE) && (Multi_sg_netgame->mode != NG_MODE_RANK_BELOW)){
		return;
	}
	
	if(((int)Ranks.size() - Multi_sg_rank_start) > Multi_sg_rank_max_display[gr_screen.res]){
		Multi_sg_rank_start++;
		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}	
}

void multi_sg_rank_display_stuff()
{
	int y,line_height,idx,count;
	char rank_name[40];

	// if he doesn't have either of the rank flags set, then ignore this
	if((Multi_sg_netgame->mode != NG_MODE_RANK_ABOVE) && (Multi_sg_netgame->mode != NG_MODE_RANK_BELOW)){
		return;
	}
		
	// display the list of ranks
	y = Msg_rank_list_coords[gr_screen.res][MSG_Y_COORD];
	line_height = gr_get_font_height() + 1;
	idx = Multi_sg_rank_start;
	count = 0;
	while ((count < (int)Ranks.size()) && (count < Multi_sg_rank_max_display[gr_screen.res]) && (idx < (int)Ranks.size())) {	
		// if its the selected item, then color it differently
		if(idx == Multi_sg_rank_select){
			gr_set_color_fast(&Color_text_selected);
		} else {
			gr_set_color_fast(&Color_text_normal);
		}

		// print the text
		multi_sg_rank_build_name(get_rank_display_name(&Ranks[idx]).c_str(), rank_name);
		gr_string(Msg_rank_list_coords[gr_screen.res][MSG_X_COORD],y,rank_name,GR_RESIZE_MENU);

		// increment stuff
		y+=line_height;
		idx++;
		count++;
	}

	// display the selected rank
	
	gr_set_color_fast(&Color_bright);
	multi_sg_rank_build_name(Ranks[Multi_sg_netgame->rank_base].name,rank_name);
	gr_string(Msg_rank_sel_coords[gr_screen.res][MSG_X_COORD],Msg_rank_sel_coords[gr_screen.res][MSG_Y_COORD],rank_name,GR_RESIZE_MENU);
	
}

void multi_sg_rank_process_select()
{
	char string[255];
	
	// if he doesn't have either of the rank flags set, then ignore this
	if((Multi_sg_netgame->mode != NG_MODE_RANK_ABOVE) && (Multi_sg_netgame->mode != NG_MODE_RANK_BELOW)){
		return;
	}
	
	// see if he's clicked on an item on the rank list
	if(Multi_sg_rank_button.pressed()){		 
		int y,item;		
		Multi_sg_rank_button.get_mouse_pos(NULL,&y);
		item = y / (gr_get_font_height() + 1);
		
		if (item + Multi_sg_rank_start < (int)Ranks.size()) {		
			// evaluate whether this rank is valid for the guy to pick		
			if(multi_sg_rank_select_valid(item + Multi_sg_rank_start)){
				gamesnd_play_iface(InterfaceSounds::USER_SELECT);

				Multi_sg_rank_select = item + Multi_sg_rank_start;						

				// set the Netgame rank
				Multi_sg_netgame->rank_base = Multi_sg_rank_select;
			} else {
				gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);

				memset(string,0,255);
				sprintf(string,
					XSTR("Illegal value for a host of your rank (%s)\n", 784),
					get_rank_display_name(&Ranks[verify_rank(Net_player->m_player->stats.rank)]).c_str());
				multi_common_add_notify(string);
			}
		}		
	}
}

void multi_sg_rank_build_name(const char *in,char *out)
{
	char use[100];
	char *first;

	strcpy_s(use,in);
	first = strtok(use," ");

	// just copy the string
	if(first == NULL){
		strcpy(out,in);
		return;
	}
	
	// if the first part of the string is lieutenant, then abbreivate it and tack on the rest of the string	
	if (stricmp(first,XSTR("lieutenant",785)) == 0) {
		first = strtok(NULL, NOX("\n"));

		// if he's not just a plain lieutenant
		if(first != NULL){
			strcpy(out,XSTR("Lt. ",786));  // [[ lieutenant ]]
			strcat(out,first);
		}
		// if he _is_ just a plain lieutenant
		else {
			strcpy(out,in);
		}
	} else {
		strcpy(out,in);
	}
}

void multi_sg_check_passwd()
{
	// check to see if the password input box has been pressed
	if(Multi_sg_game_passwd.changed()){
		Multi_sg_game_passwd.get_text(Multi_sg_netgame->passwd);
	}
}

void multi_sg_check_name()
{
	// check to see if the game name input box has been pressed
	if(Multi_sg_game_name.changed()){
		Multi_sg_game_name.get_text(Multi_sg_netgame->name);
	}
}

void multi_sg_release_passwd()
{
	// hide and disable the password input box
	Multi_sg_game_passwd.hide();
	Multi_sg_game_passwd.disable();

	// set the focus back to the name input box
	Multi_sg_game_name.set_focus();
}

int multi_sg_rank_select_valid(int rank)
{
	// rank above mode
	if(Multi_sg_netgame->mode == NG_MODE_RANK_ABOVE){
		if(Net_player->m_player->stats.rank >= rank){
			return 1;
		}
	}
	// rank below mode
	else {
		if(Net_player->m_player->stats.rank <= rank){
			return 1;
		}
	}
	
	return 0;
}

void multi_sg_select_rank_default()
{
	// pick our rank for now
	Multi_sg_rank_select = Net_player->m_player->stats.rank;

	// set the Netgame rank
	Multi_sg_netgame->rank_base = Multi_sg_rank_select;
}
		
// -------------------------------------------------------------------------------------------------
//
// MULTIPLAYER CREATE GAME screen
//

//XSTR:OFF
// bitmaps defs
const char *Multi_create_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiCreate",			// GR_640
	"2_MultiCreate"		// GR_1024
};

const char *Multi_create_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiCreate-M",		// GR_640
	"2_MultiCreate-M"		// GR_1024
};

const char *Multi_create_loading_fname[GR_NUM_RESOLUTIONS] = {
	"PleaseWait",			// GR_640
	"2_PleaseWait"			// GR_1024
};
//XSTR:ON

#define MULTI_CREATE_NUM_BUTTONS	23

// button defs
#define MC_SHOW_ALL					0
#define MC_SHOW_COOP					1
#define MC_SHOW_TEAM					2
#define MC_SHOW_DOGFIGHT			3
#define MC_PXO_REFRESH				4
#define MC_PILOT_INFO				5
#define MC_SCROLL_LIST_UP			6 
#define MC_SCROLL_LIST_DOWN		7
#define MC_SCROLL_PLAYERS_UP		8
#define MC_SCROLL_PLAYERS_DOWN	9
#define MC_MISSION_FILTER			10
#define MC_CAMPAIGN_FILTER			11
#define MC_CANCEL						12
#define MC_TEAM0						13
#define MC_TEAM1						14
#define MC_KICK						15
#define MC_CLOSE						16
#define MC_SCROLL_INFO_UP			17
#define MC_SCROLL_INFO_DOWN		18
#define MC_HOST_OPTIONS				19
#define MC_HELP						20
#define MC_OPTIONS					21
#define MC_ACCEPT						22


UI_WINDOW Multi_create_window;										// the window object for the create screen
UI_BUTTON Multi_create_player_select_button;						// for selecting players
UI_BUTTON Multi_create_list_select_button;						// for selecting missions/campaigns
int Multi_create_bitmap = -1;												// the background bitmap
UI_SLIDER2 Multi_create_slider;										// for create list

// constants for coordinate look ups
#define MC_X_COORD 0
#define MC_Y_COORD 1
#define MC_W_COORD 2
#define MC_H_COORD 3

ui_button_info Multi_create_buttons[GR_NUM_RESOLUTIONS][MULTI_CREATE_NUM_BUTTONS] = {	
	{ // GR_640
		ui_button_info("MC_00", 32,	129,	36,	158,	0),		// show all missions
		ui_button_info("MC_01", 76,	129,	71,	158,	1),		// show coop missions
		ui_button_info("MC_02", 121,	129,	119,	158,	2),		// show team missions
		ui_button_info("MC_03", 164,	129,	166,	158,	3),		// show dogfight missions
		ui_button_info("MC_04", 399,	129,	229,	130,	4),		// pxo mission refresh
		ui_button_info("MC_05", 567,	123,	467,	132,	5),		// pilot info
		ui_button_info("MC_06", 1,		161,	-1,	-1,	6),		// scroll mission info up
		ui_button_info("MC_08", 1,		304,	-1,	-1,	8),		// scroll mission info down
		ui_button_info("MC_09", 613,	160,	-1,	-1,	9),		// scroll players up
		ui_button_info("MC_10", 613,	202,	-1,	-1,	10),		// scroll players down
		ui_button_info("MC_11", 22,	346,	27,	376,	11),		// mission filter
		ui_button_info("MC_12", 104,	346,	110,	376,	12),		// campaign filter
		ui_button_info("MC_13", 392,	341,	328,	364,	13),		// cancel
		ui_button_info("MC_14", 472,	352,	482,	381,	14),		// team 0	
		ui_button_info("MC_15", 506,	352,	514,	381,	15),		// team 1
		ui_button_info("MC_16", 539,	346,	539,	381,	16),		// kick
		ui_button_info("MC_17", 589,	346,	582,	381,	17),		// close
		ui_button_info("MC_18", 1,		406,	-1,	-1,	18),		// scroll list up
		ui_button_info("MC_19", 1,		447,	-1,	-1,	19),		// scroll list down
		ui_button_info("MC_20", 499,	434,	436,	423,	20),		// host options
		ui_button_info("MC_21", 534,	426,	-1,	-1,	21),		// help
		ui_button_info("MC_22", 534,	452,	-1,	-1,	22),		// options
		ui_button_info("MC_23", 571,	426,	572,	413,	23),		// commit
	}, 	
	{ // GR_1024
		ui_button_info("2_MC_00", 51,		207,	61,	253,	0),		// show all missions
		ui_button_info("2_MC_01", 122,	207,	124,	253,	1),		// show coop missions
		ui_button_info("2_MC_02", 193,	207,	194,	253,	2),		// show team missions
		ui_button_info("2_MC_03", 263,	207,	261,	253,	3),		// show dogfight missions
		ui_button_info("2_MC_04", 639,	207,	479,	218,	4),		// pxo mission refresh
		ui_button_info("2_MC_05", 907,	197,	748,	216,	5),		// pilot info
		ui_button_info("2_MC_06", 1,		258,	-1,	-1,	6),		// scroll mission info up
		ui_button_info("2_MC_08", 1,		487,	-1,	-1,	8),		// scroll mission info down
		ui_button_info("2_MC_09", 981,	256,	-1,	-1,	9),		// scroll players up
		ui_button_info("2_MC_10", 981,	323,	-1,	-1,	10),		// scroll players down
		ui_button_info("2_MC_11",  35,	554,	46,	601,	11),		// mission filter
		ui_button_info("2_MC_12", 166,	554,	174,	601,	12),		// campaign filter
		ui_button_info("2_MC_13", 628,	545,	559,	582,	13),		// cancel
		ui_button_info("2_MC_14", 756,	564,	772,	610,	14),		// team 0	
		ui_button_info("2_MC_15", 810,	564,	826,	610,	15),		// team 1
		ui_button_info("2_MC_16", 862,	554,	872,	610,	16),		// kick
		ui_button_info("2_MC_17", 943,	554,	949,	610,	17),		// close
		ui_button_info("2_MC_18", 1,		649,	-1,	-1,	18),		// scroll list up
		ui_button_info("2_MC_19", 1,		716,	-1,	-1,	19),		// scroll list down
		ui_button_info("2_MC_20", 798,	695,	726,	667,	20),		// host options
		ui_button_info("2_MC_21", 854,	681,	-1,	-1,	21),		// help
		ui_button_info("2_MC_22", 854,	724,	-1,	-1,	22),		// options
		ui_button_info("2_MC_23", 914,	681,	932,	667,	23),		// commit
	}, 	
};

#define MULTI_CREATE_NUM_TEXT				15
UI_XSTR Multi_create_text[GR_NUM_RESOLUTIONS][MULTI_CREATE_NUM_BUTTONS] = {
	{ // GR_640
		{"All",					1256,		36,	158,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_SHOW_ALL].button},
		{"Coop",					1257,		71,	158,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_SHOW_COOP].button},
		{"Team",					1258,		119,	158,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_SHOW_TEAM].button},
		{"Dogfight",			1259,		166,	158,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_SHOW_DOGFIGHT].button},
		{"Refresh Missions",	1260,		229,	130,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_PXO_REFRESH].button},
		{"Pilot Info",			1261,		467,	132,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_PILOT_INFO].button},	
		{"Missions",			1262,		27,	376,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_MISSION_FILTER].button},
		{"Campaigns",			1263,		110,	376,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_CAMPAIGN_FILTER].button},
		{"Cancel",				387,		328,	364,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[0][MC_CANCEL].button},
		{"1",						1264,		482,	381,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_TEAM0].button},
		{"2",						1265,		514,	381,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_TEAM1].button},
		{"Kick",					1266,		539,	381,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[0][MC_KICK].button},
		{"Close",				1508,		582,	381,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[0][MC_CLOSE].button},	
		{"Host Options",		1267,		436,	423,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[0][MC_HOST_OPTIONS].button},		
		{"Commit",				1062,		572,	413,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[0][MC_ACCEPT].button}
	},		
	{ // GR_1024		
		{"All",					1256,		61,	253,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_SHOW_ALL].button},
		{"Coop",					1257,		124,	253,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_SHOW_COOP].button},
		{"Team",					1258,		194,	253,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_SHOW_TEAM].button},
		{"Dogfight",			1259,		261,	253,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_SHOW_DOGFIGHT].button},
		{"Refresh Missions",	1260,		501,	218,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_PXO_REFRESH].button},
		{"Pilot Info",			1261,		814,	216,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_PILOT_INFO].button},	
		{"Missions",			1262,		46,	601,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_MISSION_FILTER].button},
		{"Campaigns",			1263,		174,	601,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_CAMPAIGN_FILTER].button},
		{"Cancel",				387,		559,	582,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[1][MC_CANCEL].button},
		{"1",						1264,		772,	610,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_TEAM0].button},
		{"2",						1265,		826,	610,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_TEAM1].button},
		{"Kick",					1266,		872,	610,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[1][MC_KICK].button},
		{"Close",				1508,		949,	610,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[1][MC_CLOSE].button},	
		{"Host Options",		1267,		755,	683,	UI_XSTR_COLOR_GREEN,	-1,	&Multi_create_buttons[1][MC_HOST_OPTIONS].button},		
		{"Commit",				1062,		932,	667,	UI_XSTR_COLOR_PINK,	-1,	&Multi_create_buttons[1][MC_ACCEPT].button}
	},
};

// squad war checkbox
UI_CHECKBOX	Multi_create_sw_checkbox;
const char *Multi_create_sw_checkbox_fname[GR_NUM_RESOLUTIONS] = {
	"MC_SW_00",
	"MC_SW_00",
};
int Multi_create_sw_checkbox_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		6, 75
	},
	{ // GR_1024
		18, 135
	}
};
int Multi_create_sw_checkbox_text[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		6, 95
	},
	{ // GR_640
		18, 155
	},
};

// game information text areas
int Mc_list_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		105, 173, 311, 152
	},
	{ // GR_1024
		62, 275, 600, 262
	}
};

int Mc_players_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		463, 164, 144, 180
	},
	{ // GR_1024
		741, 262, 144, 180
	}
};

int Mc_info_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		47, 405, 363, 59
	},
	{ // GR_1024
		75, 648, 363, 59
	}
};

// mission icon stuff
int Mc_icon_type_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		38, -2		// y is an offset
	},
	{ // GR_1024
		61, -2		// y is an offset
	}
};

int Mc_icon_volition_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		61, -1		// y is an offset
	},
	{ // GR_1024
		98, 1		// y is an offset
	}
};

int Mc_icon_silent_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		72, 0		// y is an offset
	},
	{ // GR_1024
		115, 0		// y is an offset
	}
};

int Mc_icon_valid_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		91, 0		// y is an offset
	},
	{ // GR_1024
		146, 0		// y is an offset
	}
};

// mission/campaign list column areas
int Mc_column1_w[GR_NUM_RESOLUTIONS] = {
	194,		// GR_640
	310		// GR_1024
};

int Mc_column2_w[GR_NUM_RESOLUTIONS] = {
	38,		// GR_640
	61			// GR_1024
};

int Mc_column3_w[GR_NUM_RESOLUTIONS] = {
	77,		// GR_640
	123		// GR_1024
};

int Mc_mission_name_x[GR_NUM_RESOLUTIONS] = {
	105,		// GR_640
	168		// GR_1024
};

int Mc_mission_count_x[GR_NUM_RESOLUTIONS] = {
	314,		// GR_640
	502		// GR_1024
};

int Mc_mission_fname_x[GR_NUM_RESOLUTIONS] = {
	337,		// GR_640
	539		// GR_1024
};

int Mc_create_game_text[GR_NUM_RESOLUTIONS][2] = {
	{13, 116},	// GR_640
	{21, 186}	// GR_1024
};

int Mc_players_text[GR_NUM_RESOLUTIONS][2] = {
	{467, 150},	// GR_640
	{747, 240}	// GR_1024
};

int Mc_team_text[GR_NUM_RESOLUTIONS][2] = {
	{484, 342},	// GR_640
	{774, 547}	// GR_1024
};

int Mc_slider_coords[GR_NUM_RESOLUTIONS][4] = {
	{
		3, 197, 13, 105	// GR_640
	},
	{
		5, 316, 20, 168	// GR_1024
	}
};

const char *Mc_slider_bitmap[GR_NUM_RESOLUTIONS] = {
	"slider",
	"2_slider"
};

// player list control thingie defs
#define MULTI_CREATE_PLIST_MAX_DISPLAY		20
int Multi_create_plist_select_flag;									// flag indicating if we have a play selected
short Multi_create_plist_select_id;							// the net address of the currently selected player (for lookup)

// master tracker details
int Multi_create_frame_count;											// framecount
int Multi_create_mt_tried_login;										// attempted to login this server on the MT

// mission filter settings										
int Multi_create_filter;												// what mode we're in

// game/campaign list control defs
int Multi_create_list_max_display[GR_NUM_RESOLUTIONS] = {
	15,		// GR_640
	26			// GR_1024
};


int Multi_create_list_count;
int Multi_create_list_mode;											// 0 == mission mode, 1 == campaign mode
int Multi_create_list_start;											// where to start displaying from
int Multi_create_list_select;											// which item is currently highlighted
int Multi_create_files_loaded;

SCP_vector<multi_create_info> Multi_create_mission_list;
SCP_vector<multi_create_info> Multi_create_campaign_list;

int Multi_create_overlay_id;

// LOCAL function definitions
void multi_create_check_buttons();
void multi_create_button_pressed(int n);
void multi_create_init_as_server();
void multi_create_init_as_client();
void multi_create_do_netstuff();
void multi_create_plist_scroll_up();
void multi_create_plist_scroll_down();
void multi_create_plist_process();
void multi_create_plist_blit_normal();
void multi_create_plist_blit_team();
void multi_create_list_scroll_up();
void multi_create_list_scroll_down();
void multi_create_list_do();
void multi_create_list_select_item(int n);
void multi_create_list_blit_icons(int list_index, int y_start);
void multi_create_draw_filter_buttons();
void multi_create_set_selected_team(int team);
short multi_create_get_mouse_id();
void multi_create_refresh_pxo();
void multi_create_sw_clicked();

// since we can selectively filter out mission/campaign types we always need to map a selected index (which is relative 
// to the displayed list), to an absolute index (which is relative to the total file list - some of which may filtered out)
void multi_create_select_to_filename(int select_index,char *filename);
int multi_create_select_to_index(int select_index);

int Multi_create_should_show_popup = 0;

bool Multi_create_sort_mode = false;		// default to mission name sorting, "true" is mission filename sorting


// sorting function to sort mission lists.. Basic sorting on mission name
bool multi_create_sort_func(const multi_create_info &m1, const multi_create_info &m2)
{
	if (Multi_create_filter != MISSION_TYPE_MULTI) {
		if ( (m1.flags & Multi_create_filter) && !(m2.flags & Multi_create_filter) ) {
			return false;
		} else if ( (m2.flags & Multi_create_filter) && !(m1.flags & Multi_create_filter) ) {
			return true;
		}
	}

	int test = 0;

	if (Multi_create_sort_mode) {
		test = stricmp(m1.filename, m2.filename);
	} else {
		test = stricmp(m1.name, m2.name);
	}

	return test < 0;
}

void multi_create_list_sort(int mode)
{
	bool sort_missions = false;
	bool sort_campaigns = false;
	char selected_name[255];
	int new_index = -1;

	if (Multi_create_list_count < 0) {
		return;
	}

	switch (mode) {
		case MULTI_CREATE_SHOW_MISSIONS:
			sort_missions = true;
			break;

		case MULTI_CREATE_SHOW_CAMPAIGNS:
			sort_campaigns = true;
			break;

		default:
			sort_missions = true;
			sort_campaigns = true;
			break;
	}

	// save our current selected item so that we can restore that one after sorting
	multi_create_select_to_filename(Multi_create_list_select, selected_name);

	if (sort_missions) {
		std::sort( Multi_create_mission_list.begin(), Multi_create_mission_list.end(), multi_create_sort_func);

		for (size_t idx = 0; idx < Multi_create_mission_list.size(); idx++) {
			if ( !strcmp(selected_name, Multi_create_mission_list[idx].filename) ) {
				new_index = (int)idx;
				break;
			}
		}
	}

	if (sort_campaigns) {
		std::sort( Multi_create_campaign_list.begin(), Multi_create_campaign_list.end(), multi_create_sort_func);

		for (size_t idx = 0; idx < Multi_create_campaign_list.size(); idx++) {
			if ( !strcmp(selected_name, Multi_create_campaign_list[idx].filename) ) {
				new_index = (int)idx;
				break;
			}
		}
	}

	multi_create_list_select_item(new_index);
}

void multi_create_setup_list_data(int mode)
{	
	int idx,should_sort,switched_modes;
	
	// set the current mode
	should_sort = 0;
	switched_modes = 0;
	if ( (Multi_create_list_mode != mode) && (mode != -1) ) {
		Multi_create_list_mode = mode;	
		switched_modes = 1;
	} else if (mode == -1) {
		switched_modes = 1;
	}

	// get the mission count based upon the filter selected
	if(Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS){		
		switch (Multi_create_filter) {
			case MISSION_TYPE_MULTI:
				Multi_create_list_count = (int)Multi_create_mission_list.size();

				// if we switched modes and we have more than 0 items, sort them
				if (switched_modes && (Multi_create_list_count > 0)){
					should_sort = 1;
				}
				break;

			default : 
				Multi_create_list_count = 0;

				// find all missions which match 
				for (idx = 0; idx < (int)Multi_create_mission_list.size(); idx++) {
					if(Multi_create_mission_list[idx].flags & Multi_create_filter){
						Multi_create_list_count++;
					}
				}

				// if we switched modes and we have more than 0 items, sort them
				if (switched_modes && (Multi_create_list_count > 0)){
					should_sort = 1;
				}

				break;
		}
	} else if(Multi_create_list_mode == MULTI_CREATE_SHOW_CAMPAIGNS){
		switch (Multi_create_filter) {
			case MISSION_TYPE_MULTI:
				Multi_create_list_count = (int)Multi_create_campaign_list.size();

				// if we switched modes and we have more than 0 items, sort them
				if (switched_modes && (Multi_create_list_count > 0)){
					should_sort = 1;
				}
				break;

			default :
				Multi_create_list_count = 0;

				// find all missions which match 
				for (idx = 0; idx < (int)Multi_create_campaign_list.size(); idx++) {
					if(Multi_create_campaign_list[idx].flags & Multi_create_filter){
						Multi_create_list_count++;
					}
				}

				// if we switched modes and we have more than 0 items, sort them
				if(switched_modes && (Multi_create_list_count > 0)){
					should_sort = 1;
				}
				break;
			}
	}

	// reset the list start and selected indices
	Multi_create_list_start = 0;
	Multi_create_list_select = -1;
	multi_create_list_select_item(Multi_create_list_start);	

	// sort the list of missions if necessary
	if (should_sort) {
		multi_create_list_sort(mode);
	}

	// reset the slider
	Multi_create_slider.set_numberItems(Multi_create_list_count > gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res]) ? Multi_create_list_count-gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res]) : 0);
}

void multi_create_game_init(bool API_Access)
{
	int idx;
	ui_button_info *b;
	
	// now make sure to initialze various netgame stuff based upon whether we're on a standalone or not
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		multi_create_init_as_server();
	} else {
		multi_create_init_as_client();
	}

	// initialize the player list data		
	Multi_create_plist_select_flag = 0;
	Multi_create_plist_select_id = -1;	

	if (!API_Access) {
		// create the interface window
		Multi_create_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
		Multi_create_window.set_mask_bmap(Multi_create_bitmap_mask_fname[gr_screen.res]);

		// load the background bitmap
		Multi_create_bitmap = bm_load(Multi_create_bitmap_fname[gr_screen.res]);
		if (Multi_create_bitmap < 0) {
				// we failed to load the bitmap - this is very bad
				Int3();
		}
	}

	// close any previous existing instances of the chatbox and create a new one
	chatbox_close(); //Need to pass API_Access into these also
	chatbox_create();

	if (!API_Access) {
		// load the help overlay
		Multi_create_overlay_id = help_overlay_get_index(MULTI_CREATE_OVERLAY);
		help_overlay_set_state(Multi_create_overlay_id, gr_screen.res, 0);
	}

	// initialize the common notification messaging
	multi_common_notify_init();		

	// use the common interface palette
	multi_common_set_palette();

	if (!API_Access) {
		// create the interface buttons
		for(idx=0; idx<MULTI_CREATE_NUM_BUTTONS; idx++){
			b = &Multi_create_buttons[gr_screen.res][idx];
	
			// create the object		
			b->button.create(&Multi_create_window, "", b->x, b->y, 1, 1, ((idx == MC_SCROLL_LIST_UP) || (idx == MC_SCROLL_LIST_DOWN)), 1);

			// set the sound to play when highlighted
			b->button.set_highlight_action(common_play_highlight_sound);

			// set the ani for the button
			b->button.set_bmaps(b->filename);

			// set the hotspot
			b->button.link_hotspot(b->hotspot);		

			// some special case stuff for the pxo refresh button
			if(idx == MC_PXO_REFRESH){			
				// if not a PXO game, or if I'm not a server disable and hide the button
				if(!MULTI_IS_TRACKER_GAME || !MULTIPLAYER_MASTER){
					b->button.hide();
					b->button.disable();
				}			
			}
		}	

		// create xstrs
		for(idx=0; idx<MULTI_CREATE_NUM_TEXT; idx++){
			Multi_create_window.add_XSTR(&Multi_create_text[gr_screen.res][idx]);
		}

		// if this is a PXO game, enable the squadwar checkbox	
		Multi_create_sw_checkbox.create(&Multi_create_window, "", Multi_create_sw_checkbox_coords[gr_screen.res][0], Multi_create_sw_checkbox_coords[gr_screen.res][1], 0);
		Multi_create_sw_checkbox.set_bmaps(Multi_create_sw_checkbox_fname[gr_screen.res], 6, 0);
		if(!MULTI_IS_TRACKER_GAME){
			Multi_create_sw_checkbox.hide();
			Multi_create_sw_checkbox.disable();
		}
	}

	//Need some kind of return for if the game is a PXO game in the API

	// initialize the mission type filtering mode
	Multi_create_filter = MISSION_TYPE_MULTI;

	// initialize the list mode, and load in a list
	Multi_create_mission_list.clear();
	Multi_create_campaign_list.clear();

	Multi_create_list_mode = MULTI_CREATE_SHOW_MISSIONS;
	Multi_create_list_start = -1;
	Multi_create_list_select = -1;
	Multi_create_list_count = 0;

	if (!API_Access) {
		Multi_create_slider.create(&Multi_create_window, Mc_slider_coords[gr_screen.res][MC_X_COORD], Mc_slider_coords[gr_screen.res][MC_Y_COORD], Mc_slider_coords[gr_screen.res][MC_W_COORD],Mc_slider_coords[gr_screen.res][MC_H_COORD], -1, Mc_slider_bitmap[gr_screen.res], &multi_create_list_scroll_up, &multi_create_list_scroll_down, NULL);

		// create the player list select button
		Multi_create_player_select_button.create(&Multi_create_window, "", Mc_players_coords[gr_screen.res][MC_X_COORD], Mc_players_coords[gr_screen.res][MC_Y_COORD], Mc_players_coords[gr_screen.res][MC_W_COORD], Mc_players_coords[gr_screen.res][MC_H_COORD], 0, 1);
		Multi_create_player_select_button.hide();		
	
		// create the mission/campaign list select button
		Multi_create_list_select_button.create(&Multi_create_window, "", Mc_list_coords[gr_screen.res][MC_X_COORD], Mc_list_coords[gr_screen.res][MC_Y_COORD], Mc_list_coords[gr_screen.res][MC_W_COORD], Mc_list_coords[gr_screen.res][MC_H_COORD], 0, 1);
		Multi_create_list_select_button.hide();	

		// set hotkeys for a couple of things.
		Multi_create_buttons[gr_screen.res][MC_ACCEPT].button.set_hotkey(KEY_CTRLED+KEY_ENTER);	
	}

	// init some master tracker stuff
	Multi_create_frame_count = 0;
	Multi_create_mt_tried_login = 0;

	// remove campaign flags
	Game_mode &= ~(GM_CAMPAIGN_MODE);
	
	// send any pilots as appropriate
	multi_data_send_my_junk();

	Multi_create_files_loaded = 0;
}

void multi_create_game_do(bool API_Access)
{
	//DTP CHECK ALMISSION FLAG HERE AND SKIP THE BITMAP LOADING PROGRESS 
	//SINCE WE ALREADY HAVE A MISSION SELECTED IF THIS MISSION IS A VALID MULTIPLAYER MISSION
	//IF NOT A VALID MULTIPLAYER MISSION CONTINUE LOADING, MAYBE CALL POPUP.
	if ((Cmdline_almission) && (Net_player->flags & NETINFO_FLAG_AM_MASTER)) {	//
		multi_create_list_do(); //uhm here because off, hehe, my mind is failing right now

		// DTP Var section for the is mission multi player Check.

		char mission_name[NAME_LENGTH+1];
		int flags;
		auto filename = cf_add_ext( Cmdline_almission, FS_MISSION_FILE_EXT ); //DTP ADD EXTENSION needed next line
		flags = mission_parse_is_multi(filename, mission_name); //DTP flags will set if mission is multi

		if (flags) { //only continue if mission is multiplayer mission
			netgame_info *ng; 
			ng = &Netgame;

			char almissionname[256]; // needed, for the strncpy below
			strncpy(almissionname, Cmdline_almission,MAX_FILENAME_LEN); //DTP; copying name from cmd_almission line

			Netgame.options.respawn = 99; //override anything //for debugging, i often forget this.
			ng->respawn = Netgame.options.respawn;

			Netgame.campaign_mode = MP_SINGLE_MISSION; //multiplayer single mission. meaning Single mission, not single player

			strcpy_s(Game_current_mission_filename,almissionname); // copying almissionname to Game_current_mission_filename
			strcpy_s(Netgame.mission_name,almissionname);// copying almission name to netgame.mission_name

			Multi_sync_mode = MULTI_SYNC_PRE_BRIEFING; //DTP must be set before a call to gameseq_post_event(GS_EVENT_MULTI_MISSION_SYNC) is done as it is below.
			gameseq_post_event(GS_EVENT_MULTI_MISSION_SYNC);//DTP STart game

			Cmdline_almission = NULL; // we don't want to autoload anymore do we, we will be able to quit. halleluja. Startgame has already been disabled, so no need to turn of "Cmdline_start_netgame"
			return;	// we don't need to check or set regarding ships/weapons anything as we are already progressing into mission so return
		}
		else {
			popup(PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR(" Not a multi player-mission",9999)); //DTP startgame popup pilot error
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
			Cmdline_almission = NULL; //DTP make sure this gets nullified.
		
		}
	}
	
	int player_index;
	const char *loading_str = XSTR("Loading", 1336);
	int str_w, str_h;

	// set this if we want to show the pilot info popup
	Multi_create_should_show_popup = 0;

	// first thing is to load the files
	if ( !Multi_create_files_loaded ) {
		// if I am a client, send a list request to the server for the missions
		if ( MULTIPLAYER_CLIENT ) {
			send_mission_list_request( MISSION_LIST_REQUEST );
		} else {
			if (!API_Access) {
				int loading_bitmap;

				loading_bitmap = bm_load(Multi_create_loading_fname[gr_screen.res]);

				// draw the background, etc
				gr_reset_clip();
				GR_MAYBE_CLEAR_RES(Multi_create_bitmap);
				if(Multi_create_bitmap != -1){
					gr_set_bitmap(Multi_create_bitmap);
					gr_bitmap(0, 0, GR_RESIZE_MENU);
				}
				chatbox_render();
				if ( loading_bitmap > -1 ){
					gr_set_bitmap(loading_bitmap);
				}
				gr_bitmap( Please_wait_coords[gr_screen.res][MC_X_COORD], Please_wait_coords[gr_screen.res][MC_Y_COORD], GR_RESIZE_MENU );

				// draw "Loading" on it
				gr_set_color_fast(&Color_normal);
				font::set_font(font::FONT2);
				gr_get_string_size(&str_w, &str_h, loading_str);
				gr_string((gr_screen.max_w_unscaled - str_w) / 2, (gr_screen.max_h_unscaled - str_h) / 2, loading_str, GR_RESIZE_MENU);
				font::set_font(font::FONT1);

				gr_flip();
			}
			multi_create_list_load_missions();
			multi_create_list_load_campaigns();

			if (!API_Access){
				Multi_create_slider.set_numberItems(int(Multi_create_mission_list.size()) > gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res]) ? int(Multi_create_mission_list.size())-gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res]) : 0);
			}

			// if this is a tracker game, validate missions
			if (MULTI_IS_TRACKER_GAME) {
				multi_update_valid_missions();
			}

			if (!API_Access) {
				// update the file list
				multi_create_setup_list_data(MULTI_CREATE_SHOW_MISSIONS);
				// the above function doesn't sort initially, so we need this to take care of it
				multi_create_list_sort(MULTI_CREATE_SHOW_MISSIONS);
				// the sort function probably changed our selection, but here we always need it to zero
				multi_create_list_select_item(0);
			}
		}

		// don't bother setting netgame state if ont the server
		if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
			// tell PXO about this game
			if ( multi_fs_tracker_inited() ) {
				multi_fs_tracker_login_freespace();
			}

			Netgame.game_state = NETGAME_STATE_FORMING;
			send_netgame_update_packet();
		}	

		// if we're on the standalone we have to tell him that we're now in the host setup screen	
		Net_player->state = NETPLAYER_STATE_HOST_SETUP;	
		send_netplayer_update_packet();

		Multi_create_files_loaded = 1;
	}

	if (!API_Access) {
		int k = chatbox_process();
		k = Multi_create_window.process(k, 0);

		switch (k) {
		// same as the cancel button
		case KEY_ESC: {
			if (help_overlay_active(Multi_create_overlay_id)) {
				help_overlay_set_state(Multi_create_overlay_id, gr_screen.res, 0);
			} else {
				gamesnd_play_iface(InterfaceSounds::USER_SELECT);
				multi_quit_game(PROMPT_HOST);
			}

			break;
		}

		case KEY_CTRLED | KEY_SHIFTED | KEY_S:
			Multi_create_sort_mode = !Multi_create_sort_mode;
			multi_create_list_sort(Multi_create_list_mode);
			break;
		}

		if (mouse_down(MOUSE_LEFT_BUTTON)) {
			help_overlay_set_state(Multi_create_overlay_id, gr_screen.res, 0);
		}

		// process any button clicks
		multi_create_check_buttons();
	}
	// do any network related stuff
	multi_create_do_netstuff(); 

	if (!API_Access) {
		// draw the background, etc
		gr_reset_clip();
		GR_MAYBE_CLEAR_RES(Multi_create_bitmap);
		if (Multi_create_bitmap != -1) {
			gr_set_bitmap(Multi_create_bitmap);
			gr_bitmap(0, 0, GR_RESIZE_MENU);
		}

		// if we're not in team vs. team mode, don't draw the team buttons
		if (!(Netgame.type_flags & NG_TYPE_TEAM)) {
			Multi_create_buttons[gr_screen.res][MC_TEAM0].button.hide();
			Multi_create_buttons[gr_screen.res][MC_TEAM1].button.hide();
			Multi_create_buttons[gr_screen.res][MC_TEAM0].button.disable();
			Multi_create_buttons[gr_screen.res][MC_TEAM1].button.disable();
		} else {
			Multi_create_buttons[gr_screen.res][MC_TEAM0].button.enable();
			Multi_create_buttons[gr_screen.res][MC_TEAM1].button.enable();
			Multi_create_buttons[gr_screen.res][MC_TEAM0].button.unhide();
			Multi_create_buttons[gr_screen.res][MC_TEAM1].button.unhide();
		}

		// draw the window itself
		Multi_create_window.draw();

		gr_set_color_fast(&Color_normal);

		// draw Create Game text
		gr_string(Mc_create_game_text[gr_screen.res][MC_X_COORD],
			Mc_create_game_text[gr_screen.res][MC_Y_COORD],
			XSTR("Create Game", 1268),
			GR_RESIZE_MENU);

		// draw players text
		gr_string(Mc_players_text[gr_screen.res][MC_X_COORD],
			Mc_players_text[gr_screen.res][MC_Y_COORD],
			XSTR("Players", 1269),
			GR_RESIZE_MENU);

		// draw players text
		gr_string(Mc_team_text[gr_screen.res][MC_X_COORD],
			Mc_team_text[gr_screen.res][MC_Y_COORD],
			XSTR("Team", 1258),
			GR_RESIZE_MENU);

		// process and display the player list
		// NOTE : this must be done before the buttons are checked to insure that a player hasn't dropped
		multi_create_plist_process();
		if (Netgame.type_flags & NG_TYPE_TEAM) {
			multi_create_plist_blit_team();
		} else {
			multi_create_plist_blit_normal();
		}

		// process and display the game/campaign list
		multi_create_list_do();

		// draw the correct mission filter button
		multi_create_draw_filter_buttons();

		// display any text in the info area
		multi_common_render_text();

		// display any pending notification messages
		multi_common_notify_do();

		// force the correct mission/campaign button to light up
		if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
			Multi_create_buttons[gr_screen.res][MC_MISSION_FILTER].button.draw_forced(2);
		} else {
			Multi_create_buttons[gr_screen.res][MC_CAMPAIGN_FILTER].button.draw_forced(2);
		}

		// force draw the closed button if it is toggled on
		if (Netgame.flags & NG_FLAG_TEMP_CLOSED) {
			Multi_create_buttons[gr_screen.res][MC_CLOSE].button.draw_forced(2);
		}

		// process and show the chatbox thingie
		chatbox_render();

		// draw tooltips
		Multi_create_window.draw_tooltip();

		// display the voice status indicator
		multi_common_voice_display_status();

		// blit the help overlay if necessary
		help_overlay_maybe_blit(Multi_create_overlay_id, gr_screen.res);

		// test code
		if (MULTI_IS_TRACKER_GAME) {
			if (Netgame.type_flags & NG_TYPE_SW) {
				gr_set_color_fast(&Color_bright);
			} else {
				gr_set_color_fast(&Color_normal);
			}
			gr_string(Multi_create_sw_checkbox_text[gr_screen.res][0],
				Multi_create_sw_checkbox_text[gr_screen.res][1],
				"SquadWar",
				GR_RESIZE_MENU);
		}

		// flip the buffer
		gr_flip();

		// if we're supposed to show the pilot info popup, do it now
		if (Multi_create_should_show_popup) {
			// get the player index and address of the player item the mouse is currently over
			if (Multi_create_plist_select_flag) {
				player_index = find_player_index(Multi_create_plist_select_id);
				if (player_index != -1) {
					multi_pinfo_popup(&Net_players[player_index]);
				}
			}
		}
	}
	// increment the frame count
	Multi_create_frame_count++;	
}

void multi_create_game_close()
{
	// unload any bitmaps
	if(!bm_unload(Multi_create_bitmap)){
		nprintf(("General","WARNING : could not unload background bitmap %s\n",Multi_create_bitmap_fname[gr_screen.res]));
	}		
	
	// destroy the chatbox
	// chatbox_close();
	
	// destroy the UI_WINDOW
	Multi_create_window.destroy();
}

void multi_create_check_buttons()
{
	int idx;
	for(idx=0;idx<MULTI_CREATE_NUM_BUTTONS;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_create_buttons[gr_screen.res][idx].button.pressed()){
			multi_create_button_pressed(idx);
			break;
		}
	}

	// if the squad war checkbox was clicked
	if(Multi_create_sw_checkbox.changed()){
		multi_create_sw_clicked();
	}
}

void multi_create_button_pressed(int n)
{
	int idx;
	
	switch(n){
	case MC_CANCEL :
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_quit_game(PROMPT_HOST);		
		break;
	case MC_ACCEPT :	
		// if valid commit conditions have not been met
		if (!multi_create_ok_to_commit(multi_create_select_to_index(Multi_create_list_select))) {
			break;
		}

		// commit
		multi_create_accept_hit(Multi_create_list_mode, multi_create_select_to_index(Multi_create_list_select));		
		break;

	// help button
	case MC_HELP :
		if(!help_overlay_active(Multi_create_overlay_id)){
			help_overlay_set_state(Multi_create_overlay_id,gr_screen.res,1);
		} else {
			help_overlay_set_state(Multi_create_overlay_id,gr_screen.res,0);
		}
		break;

	// scroll the info text box up
	case MC_SCROLL_INFO_UP:
		multi_common_scroll_text_up();
		break;

	// scroll the info text box down
	case MC_SCROLL_INFO_DOWN:
		multi_common_scroll_text_down();
		break;

	// scroll the player list up
	case MC_SCROLL_PLAYERS_UP:
		multi_create_plist_scroll_up();
		break;

	// scroll the player list down
	case MC_SCROLL_PLAYERS_DOWN:
		multi_create_plist_scroll_down();
		break;

	// scroll the game/campaign list up
	case MC_SCROLL_LIST_UP:
		multi_create_list_scroll_up();
		Multi_create_slider.forceUp();	// move slider up
		break;

	// scroll the game/campaign list down
	case MC_SCROLL_LIST_DOWN:
		multi_create_list_scroll_down();
		Multi_create_slider.forceDown();	// move slider down
		break;

	// go to the options screen
	case MC_OPTIONS:		
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		gameseq_post_event(GS_EVENT_OPTIONS_MENU);
		break;	

	// show all missions
	case MC_SHOW_ALL:
		if(Multi_create_filter != MISSION_TYPE_MULTI){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Multi_create_filter = MISSION_TYPE_MULTI;
			multi_create_setup_list_data(Multi_create_list_mode);						// update the file list
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// show cooperative missions
	case MC_SHOW_COOP:
		if(Multi_create_filter != MISSION_TYPE_MULTI_COOP){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Multi_create_filter = MISSION_TYPE_MULTI_COOP;			
			multi_create_setup_list_data(Multi_create_list_mode);						// update the file list
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// show team vs. team missions
	case MC_SHOW_TEAM:
		if(Multi_create_filter != MISSION_TYPE_MULTI_TEAMS){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Multi_create_filter = MISSION_TYPE_MULTI_TEAMS;	
			multi_create_setup_list_data(Multi_create_list_mode);						// update the file list
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;	

	// show dogfight missions
	case MC_SHOW_DOGFIGHT:
		if (Multi_create_filter != MISSION_TYPE_MULTI_DOGFIGHT){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Multi_create_filter = MISSION_TYPE_MULTI_DOGFIGHT;
			multi_create_setup_list_data(Multi_create_list_mode);						// update the file list
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// toggle temporary netgame closed on/off
	case MC_CLOSE:
		if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
			Netgame.flags ^= NG_FLAG_TEMP_CLOSED;
		} else {
			Netgame.options.flags |= MLO_FLAG_TEMP_CLOSED;
			multi_options_update_netgame();
		}
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		break;

	// kick the currently selected player (if possible)
	case MC_KICK:
		// lookup the player at the specified index		
		if(Multi_create_plist_select_flag){		 
			idx = find_player_index(Multi_create_plist_select_id);
			// kick him - but don't ban him
			if(idx != -1){			
				multi_kick_player(idx,0);				
			}
		}
		break;
			
	// switch to individual mission mode and load in a list
	case MC_MISSION_FILTER:
		if(Multi_create_list_mode != MULTI_CREATE_SHOW_MISSIONS){
			Netgame.campaign_mode = MP_SINGLE_MISSION;

			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			
			// update the file list
			multi_create_setup_list_data(MULTI_CREATE_SHOW_MISSIONS);						
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// switch to campaign mode and load in a list
	case MC_CAMPAIGN_FILTER:		
		// switch off squad war
		Multi_create_sw_checkbox.set_state(0);
		Netgame.type_flags = NG_TYPE_COOP;

		if(Multi_create_list_mode != MULTI_CREATE_SHOW_CAMPAIGNS){
			Netgame.campaign_mode = MP_CAMPAIGN;

			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			
			// update the file list
			multi_create_setup_list_data(MULTI_CREATE_SHOW_CAMPAIGNS);						
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
		break;

	// attempt to set the selected player's team
	case MC_TEAM0:
		multi_create_set_selected_team(0);
		if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
			multi_team_send_update();
		}
		break;

	// attempt to set the selected player's team
	case MC_TEAM1:
		multi_create_set_selected_team(1);
		if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
			multi_team_send_update();
		}
		break;	

	// popup the pilot info dialog for the currently selected pilot (will occur at the end of the frame)
	case MC_PILOT_INFO:
		Multi_create_should_show_popup = 1;
		break;

	// go to the host options screen
	case MC_HOST_OPTIONS:
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		gameseq_post_event(GS_EVENT_MULTI_HOST_OPTIONS);
		break;

	// refresh PXO file list
	case MC_PXO_REFRESH:		
		if(!MULTI_IS_TRACKER_GAME){
			break;
		}
		multi_create_refresh_pxo();		
		break;

	default :
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		multi_common_add_notify(XSTR("Not implemented yet!",760));		
		break;
	}
}

// do stuff like pinging servers, sending out requests, etc
// # Kazan # -- This apparently DOES NOT Apply to Standalones
void multi_create_do_netstuff()
{

}

// if not on a standalone
void multi_create_init_as_server()
{
	// set me up as the host and master
	Net_player->flags |= (NETINFO_FLAG_AM_MASTER | NETINFO_FLAG_GAME_HOST);

	// setup port forwarding
	multi_port_forward_init();

	// setup mdns
	if ( !MULTI_IS_TRACKER_GAME && (Net_player->p_info.options.flags & MLO_FLAG_LOCAL_BROADCAST) ) {
		multi_mdns_service_init();
	}
}

// if on a standalone
void multi_create_init_as_client()
{
	Net_player->flags |= NETINFO_FLAG_GAME_HOST;	
}

// scroll up through the player list
void multi_create_plist_scroll_up()
{	
	gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
}

// scroll down through the player list
void multi_create_plist_scroll_down()
{	
	gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
}

void multi_create_plist_process()
{
	int test_count,idx,player_index;
	
	// first determine if there are 0 players in the game. This should never happen since the host is _always_ in the game
	test_count = 0;
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
			test_count++;
		}
	}
	if(test_count <= 0){
		return;
	}
	
	// if we had a selected item but that player has left, select myself instead
	if(Multi_create_plist_select_flag){
		player_index = find_player_index(Multi_create_plist_select_id);
		if(player_index == -1){
			Multi_create_plist_select_id = Net_player->player_id;
		}
	} else {
		Multi_create_plist_select_flag = 1;
		Multi_create_plist_select_id = Net_player->player_id;		
	}	
		
	// if the player has clicked somewhere in the player list area
	if(Multi_create_player_select_button.pressed()){				
		short player_id;

		// get the player index and address of the player item the mouse is currently over
		player_id = multi_create_get_mouse_id();
		player_index = find_player_index(player_id);
		if(player_index != -1){
			Multi_create_plist_select_flag = 1;
			Multi_create_plist_select_id = player_id;			
		} 
	}		
}

void multi_create_plist_blit_normal()
{
	int idx;		
	char str[CALLSIGN_LEN+5];
	int y_start = Mc_players_coords[gr_screen.res][MC_Y_COORD];	
	int line_height = gr_get_font_height() + 1;
	int total_offset;

	// display all the players	
	for(idx=0;idx<MAX_PLAYERS;idx++){		
		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
			// total x offset
			total_offset = 0;

			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}		
			
			// make sure the string will fit, then display it
			strcpy_s(str,Net_players[idx].m_player->callsign);
			if(Net_players[idx].flags & NETINFO_FLAG_OBSERVER){
				strcat_s(str,XSTR("(O)",787));  // [[ Observer ]]
			}
			font::force_fit_string(str,CALLSIGN_LEN,Mc_players_coords[gr_screen.res][MC_W_COORD] - total_offset);
			gr_string(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);

			y_start += line_height;			
		}
	}		
}

void multi_create_plist_blit_team()
{
	int idx;		
	char str[CALLSIGN_LEN+1];
	int y_start = Mc_players_coords[gr_screen.res][MC_Y_COORD];	
	int line_height = gr_get_font_height() + 1;
	int total_offset;

	// display all the red players first
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 0)){
			// reset total offset
			total_offset = 0;

			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);

					// be sure to blit the correct team button 
					Multi_create_buttons[gr_screen.res][MC_TEAM0].button.draw_forced(2);
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);

					// be sure to blit the correct team button 
					Multi_create_buttons[gr_screen.res][MC_TEAM0].button.draw_forced(2);
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}		

			// blit the red team indicator			
			if(Net_players[idx].flags & NETINFO_FLAG_TEAM_CAPTAIN){
				if(Multi_common_icons[MICON_TEAM0_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0_SELECT]);
					gr_bitmap(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset, y_start-2, GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM0_SELECT][0] + 1;			
				}
			} else {
				if(Multi_common_icons[MICON_TEAM0] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0]);
					gr_bitmap(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset, y_start-2, GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM0][0] + 1;			
				}				
			}						

			// make sure the string will fit
			strcpy_s(str,Net_players[idx].m_player->callsign);
			if(Net_players[idx].flags & NETINFO_FLAG_OBSERVER){
				strcat_s(str,XSTR("(O)",787));
			}
			font::force_fit_string(str,CALLSIGN_LEN,Mc_players_coords[gr_screen.res][MC_W_COORD] - total_offset);

			// display him in the correct half of the list depending on his team
			gr_string(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);
			y_start += line_height;
		}
	}	
	
	// display all the green players next
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 1)){
			// reset total offset
			total_offset = 0;

			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);

					// be sure to blit the correct team button 
					Multi_create_buttons[gr_screen.res][MC_TEAM1].button.draw_forced(2);
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_create_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);

					// be sure to blit the correct team button 
					Multi_create_buttons[gr_screen.res][MC_TEAM1].button.draw_forced(2);
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}		

			// blit the red team indicator			
			if(Net_players[idx].flags & NETINFO_FLAG_TEAM_CAPTAIN){
				if(Multi_common_icons[MICON_TEAM1_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1_SELECT]);
					gr_bitmap(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset, y_start-2, GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM1_SELECT][0] + 1;
				}				
			} else {
				if(Multi_common_icons[MICON_TEAM1] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1]);
					gr_bitmap(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset, y_start-2, GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM1][0] + 1;
				}
			}

			// make sure the string will fit
			strcpy_s(str,Net_players[idx].m_player->callsign);
			if(Net_players[idx].flags & NETINFO_FLAG_OBSERVER){
				strcat_s(str,XSTR("(O)",787));
			}
			font::force_fit_string(str,CALLSIGN_LEN,Mc_players_coords[gr_screen.res][MC_W_COORD] - total_offset);

			// display him in the correct half of the list depending on his team
			gr_string(Mc_players_coords[gr_screen.res][MC_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);
			y_start += line_height;
		}
	}			
}

void multi_create_list_scroll_up()
{
	if(Multi_create_list_start > 0){
		Multi_create_list_start--;		

		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}
}

void multi_create_list_scroll_down()
{
	if((Multi_create_list_count - Multi_create_list_start) > gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res])){
		Multi_create_list_start++;		

		gamesnd_play_iface(InterfaceSounds::SCROLL);
	} else {
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
	}
}

// gets a list of multiplayer misisons
void multi_create_list_load_missions()
{
	char *fname, mission_name[NAME_LENGTH+1];
	char wild_card[10];
	int file_count, idx;
	char **file_list = NULL;

	Multi_create_mission_list.clear();

	memset( wild_card, 0, sizeof(wild_card) );
	snprintf(wild_card, sizeof(wild_card), "*%s", FS_MISSION_FILE_EXT);

	file_list = (char**) vm_malloc( sizeof(char*) * 1024 );

	if (file_list == NULL) {
		return;
	}

	file_count = cf_get_file_list(1024, file_list, CF_TYPE_MISSIONS, wild_card);

	// maybe create a standalone dialog
	if (Game_mode & GM_STANDALONE_SERVER) {
		std_create_gen_dialog("Loading missions");
		std_gen_set_text("Mission:", 1);
	}

	for (idx = 0; idx < file_count; idx++) {
		int flags, max_players;
		uint m_respawn;
		bool lcl_weirdness = false;

		fname = file_list[idx];
		
		// tack on any necessary file extension
		auto filename = cf_add_ext( fname, FS_MISSION_FILE_EXT );

		if (Game_mode & GM_STANDALONE_SERVER) {			
			std_gen_set_text(filename, 2);
		}

		// activate tstrings check
		Lcl_unexpected_tstring_check = &lcl_weirdness;

		flags = mission_parse_is_multi(filename, mission_name);

		// maybe log
		if (lcl_weirdness)
			mprintf(("Skipping %s due to XSTR mismatch\n", filename));

		// deactivate tstrings check
		Lcl_unexpected_tstring_check = nullptr;

		// if the mission is a multiplayer mission, and we can list it, then add it to the mission list
		if (flags && !mission_is_ignored(filename) && !lcl_weirdness) {
			max_players = mission_parse_get_multi_mission_info( filename );
			m_respawn = The_mission.num_respawns;

			multi_create_info mcip;

			strcpy_s(mcip.filename, filename );
			strcpy_s(mcip.name, mission_name );
			mcip.flags = flags;
			mcip.respawn = m_respawn;
			mcip.max_players = (ubyte)max_players;

			// get any additional information for possibly builtin missions
			auto fb = game_find_builtin_mission(filename);
			if(fb != NULL){					
			}

			Multi_create_mission_list.push_back( mcip );
		}
	}

	if (file_list) {
		for (idx = 0; idx < file_count; idx++) {
			if (file_list[idx]) {
				vm_free(file_list[idx]);
				file_list[idx] = NULL;
			}
		}

		vm_free(file_list);
		file_list = NULL;
	}

	// maybe create a standalone dialog
	if (Game_mode & GM_STANDALONE_SERVER) {
		std_destroy_gen_dialog();		
	}
}

void multi_create_list_load_campaigns()
{
	int idx, file_count;
	int campaign_type,max_players;
	SCP_string title;
	char wild_card[10];
	char **file_list = NULL;

	Multi_create_campaign_list.clear();

	memset( wild_card, 0, sizeof(wild_card) );
	snprintf(wild_card, sizeof(wild_card), "*%s", FS_CAMPAIGN_FILE_EXT);

	file_list = (char**) vm_malloc( sizeof(char*) * 1024 );

	if (file_list == NULL) {
		return;
	}

	file_count = cf_get_file_list(1024, file_list, CF_TYPE_MISSIONS, wild_card);

	// maybe create a standalone dialog
	if (Game_mode & GM_STANDALONE_SERVER) {
		std_create_gen_dialog("Loading campaigns");
		std_gen_set_text("Campaign:", 1);
	}

	for (idx = 0; idx < file_count; idx++) {
		int flags;
		char name[NAME_LENGTH];

		auto fname = file_list[idx];
		
		// tack on any necessary file extension
		auto filename = cf_add_ext( fname, FS_CAMPAIGN_FILE_EXT );

		if (Game_mode & GM_STANDALONE_SERVER) {			
			std_gen_set_text(filename, 2);
		}

		flags = mission_campaign_parse_is_multi( filename, name );

		// if the campaign is a multiplayer campaign, and we can list it, and we can get its info, then add the data to the campaign list items
		if( flags != CAMPAIGN_TYPE_SINGLE && !campaign_is_ignored(filename) && mission_campaign_get_info(filename, title, &campaign_type, &max_players)) {
			multi_create_info mcip;

			strcpy_s(mcip.filename, filename );
			strcpy_s(mcip.name, name );
			
			// setup various flags
			if ( flags == CAMPAIGN_TYPE_MULTI_COOP ){
				mcip.flags = MISSION_TYPE_MULTI_COOP | MISSION_TYPE_MULTI;
			} else if ( flags == CAMPAIGN_TYPE_MULTI_TEAMS ) {
				mcip.flags = MISSION_TYPE_MULTI_TEAMS | MISSION_TYPE_MULTI;
			} else {
				Int3();			// bogus campaign multi type -- find allender
			}							

			// 0 respawns for campaign files (should be contained within the mission files themselves)
			mcip.respawn = 0;

			// 0 max players for campaign files
			mcip.max_players = (unsigned char)max_players;

			// get any additional information for possibly builtin missions
			auto fb = game_find_builtin_mission(filename);
			if(fb != NULL){					
			}

			Multi_create_campaign_list.push_back( mcip );
		}
	}

	if (file_list) {
		for (idx = 0; idx < file_count; idx++) {
			if (file_list[idx]) {
				vm_free(file_list[idx]);
				file_list[idx] = NULL;
			}
		}

		vm_free(file_list);
		file_list = NULL;
	}

	// maybe create a standalone dialog
	if (Game_mode & GM_STANDALONE_SERVER) {
		std_destroy_gen_dialog();		
	}
}

void multi_create_list_do()
{
	int idx;
	int start_index,stop_index;
	int line_height = gr_get_font_height() + 1;
	char selected_name[256];

	// bail early if there aren't any selectable items
	if(Multi_create_list_count == 0){
		return;
	}
	
	// first check to see if the user has clicked on an item
	if(Multi_create_list_select_button.pressed()){		 
		int y,item;				
		Multi_create_list_select_button.get_mouse_pos(NULL,&y);
		item = (y / line_height);

		// make sure we are selectedin valid indices
		if((item < Multi_create_list_max_display[gr_screen.res]) && (item >= 0)){					
			item += Multi_create_list_start;		

			if(item < Multi_create_list_count){		
				multi_create_list_select_item(item);
				gamesnd_play_iface(InterfaceSounds::IFACE_MOUSE_CLICK);
			}		
		}
	}	

	// bail early if we don't have a start position
	if(Multi_create_list_start == -1){
		return;
	}

	// display the list of individual campaigns/missions
	int count = 0;
	int y_start = Mc_list_coords[gr_screen.res][MC_Y_COORD];		

	start_index = multi_create_select_to_index(Multi_create_list_start);
	stop_index = (int)((Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) ? Multi_create_mission_list.size() : Multi_create_campaign_list.size());

	for (idx = start_index; idx < stop_index; idx++) {
		multi_create_info *mcip;

		if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
			mcip = &Multi_create_mission_list[idx];
		} else {
			mcip = &Multi_create_campaign_list[idx];
		}
		
		// see if we should drop out
		if(count == gr_get_dynamic_font_lines(Multi_create_list_max_display[gr_screen.res])){
			break;
		}

		// see if we should filter out this mission
		if ( !(mcip->flags & Multi_create_filter) ) {
			continue;
		}
		
		// highlight the selected item
		multi_create_select_to_filename(Multi_create_list_select, selected_name);

		if ( !strcmp(selected_name, mcip->filename) ) {		
			gr_set_color_fast(&Color_text_selected);
		} else {
			gr_set_color_fast(&Color_text_normal);
		}		

		// draw the type icon		
		multi_create_list_blit_icons(idx, y_start);		
		
		// force fit the mission name string
		strcpy_s(selected_name, mcip->name);
		font::force_fit_string(selected_name, 255, Mc_column1_w[gr_screen.res]);
		gr_string(Mc_mission_name_x[gr_screen.res], y_start, selected_name, GR_RESIZE_MENU);

		// draw the max players if in mission mode		
		sprintf(selected_name, "%d", (int)mcip->max_players);
		gr_string(Mc_mission_count_x[gr_screen.res], y_start, selected_name, GR_RESIZE_MENU);		

		// force fit the mission filename string
		strcpy_s(selected_name, mcip->filename);
		font::force_fit_string(selected_name, 255, Mc_column3_w[gr_screen.res]);
		gr_string(Mc_mission_fname_x[gr_screen.res], y_start, selected_name, GR_RESIZE_MENU);

		y_start += line_height;
		count++;
	}
}

// Here we have the absolute index to the mission item we're working with and the mode
// so we can set the data without bothering to check the UI anymore
void multi_create_list_set_item(int abs_index, int mode) {

	int campaign_type = -1, max_players = 0;
	SCP_string title;
	netgame_info ng_temp;
	netgame_info* ng;
	multi_create_info* mcip = NULL;

	char* campaign_desc = nullptr;

	// if not on the standalone server
	if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
		ng = &Netgame;
	}
	// on the standalone
	else {
		ng = &ng_temp;
	}

	// set the mission name
	if (mode == MULTI_CREATE_SHOW_MISSIONS) {
		strcpy(ng->mission_name, Multi_create_mission_list[abs_index].filename);
	} else {
		strcpy(ng->campaign_name, Multi_create_campaign_list[abs_index].filename);
	}

	// make sure the netgame type is properly set
	int old_type = Netgame.type_flags;

	if (abs_index != -1) {
		if (mode == MULTI_CREATE_SHOW_MISSIONS) {
			mcip = &Multi_create_mission_list[abs_index];
		} else {
			mcip = &Multi_create_campaign_list[abs_index];
		}

		if (mcip->flags & MISSION_TYPE_MULTI_TEAMS) {
			// if we're in squad war mode, leave it as squad war
			if (old_type & NG_TYPE_SW) {
				ng->type_flags = NG_TYPE_SW;
			} else {
				ng->type_flags = NG_TYPE_TVT;
			}
		} else if (mcip->flags & MISSION_TYPE_MULTI_COOP) {
			ng->type_flags = NG_TYPE_COOP;
		} else if (mcip->flags & MISSION_TYPE_MULTI_DOGFIGHT) {
			ng->type_flags = NG_TYPE_DOGFIGHT;
		}
	}

	// if we're no longer in a TvT game, just uncheck the squadwar checkbox
	if (!(ng->type_flags & NG_TYPE_TEAM)) {
		Multi_create_sw_checkbox.set_state(0);
	}

	// if we switched from something else to team vs. team mode, do some special processing
	if ((ng->type_flags & NG_TYPE_TEAM) && (ng->type_flags != old_type) &&
		(Net_player->flags & NETINFO_FLAG_AM_MASTER)) {
		multi_team_reset();
	}

	switch (mode) {
	case MULTI_CREATE_SHOW_MISSIONS:
		// don't forget to update the info box window thingie
		if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
			ship_level_init(); // mwa -- 10/15/97.  Call this function to reset number of ships in mission
			ng->max_players = mission_parse_get_multi_mission_info(ng->mission_name);

			Assert(ng->max_players > 0);
			strncpy(ng->title, The_mission.name.c_str(), NAME_LENGTH);
			ng->title[NAME_LENGTH] = '\0';

			// set the information area text
			Multi_netgame_common_description = The_mission.mission_desc;
			multi_common_set_text(Multi_netgame_common_description.c_str());
		}
		// if we're on the standalone, send a request for the description
		else {
			send_netgame_descript_packet(&Netgame.server_addr, 0);
			multi_common_set_text("");
		}

		// set the respawns as appropriate
		if (mcip) {
			if (Netgame.options.respawn <= mcip->respawn) {
				ng->respawn = Netgame.options.respawn;
				nprintf(("Network",
					"Using netgame options for respawn count (%d %d)\n",
					Netgame.options.respawn,
					mcip->respawn));
			} else {
				ng->respawn = mcip->respawn;
				nprintf(("Network",
					"Using mission settings for respawn count (%d %d)\n",
					Netgame.options.respawn,
					mcip->respawn));
			}
		}
		break;
	case MULTI_CREATE_SHOW_CAMPAIGNS:
		char* first_mission = nullptr;
		mission* mp = &The_mission;

		// if not on the standalone server
		if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
			// get the campaign info
			if (!mission_campaign_get_info(ng->campaign_name,
					title,
					&campaign_type,
					&max_players,
					&campaign_desc,
					&first_mission))
			{
				nprintf(("Network", "MC: Failed to get campaign info for '%s'!\n", ng->campaign_name));
				memset(ng->campaign_name, 0, sizeof(ng->campaign_name));
			}

			memset(ng->title, 0, sizeof(ng->title));
			strcpy_s(ng->title, title.c_str());
			ng->max_players = max_players;

			nprintf(("Network", "MC MAX PLAYERS : %d\n", ng->max_players));

			// set the information area text
			// Cyborg17 - Now that we can have both descriptions, markers in the text are helpful.
			Multi_netgame_common_description = PRE_CAMPAIGN_DESC;

			if (campaign_desc) {
				Multi_netgame_common_description += campaign_desc;
			} else {
				Multi_netgame_common_description += "No description available.";
			}

			Multi_netgame_common_description += DOUBLE_NEW_LINE;
			Multi_netgame_common_description += PRE_MISSION_DESC;

			int rc = get_mission_info(first_mission, mp, true);

			if (!rc && strlen(mp->mission_desc)) {
				Multi_netgame_common_description += mp->mission_desc;
			} else {
				Multi_netgame_common_description += "No description available.";
			}

			multi_common_set_text(Multi_netgame_common_description.c_str());

			// free the malloc'ed strings from mission_campaign_get_info()
			if (campaign_desc != nullptr) {
				vm_free(campaign_desc);
			}

			if (first_mission != nullptr) {
				vm_free(first_mission);
			}

			// standalones should now be able to request the info.
		} else {
			send_netgame_descript_packet(&Netgame.server_addr, 0);
			multi_common_set_text("");
		}

		// netgame respawns are always 0 for campaigns (until the first mission is loaded)
		ng->respawn = 0;
		break;
	}

	if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
		// update players
		send_netgame_update_packet();

		// update all machines about stuff like respawns, etc.
		multi_options_update_netgame();
	} else {
		multi_options_update_mission(ng, mode == MULTI_CREATE_SHOW_CAMPAIGNS ? 1 : 0);
	}
}

// takes care of stuff like changing indices around and setting up the netgame structure
void multi_create_list_select_item(int n)
{
	int abs_index;

	if ( n != Multi_create_list_select ) {
		// check to see if this is a valid index, and bail if it is not
		abs_index = multi_create_select_to_index(n);
		if(abs_index == -1){
			return;
		}

		Multi_create_list_select = n;

		// now that we have the absolute index and the mode, do all the things
		multi_create_list_set_item(abs_index, Multi_create_list_mode);
	}
}

bool multi_is_item_builtin_volition(const char* filename)
{
	auto fb = game_find_builtin_mission(filename);
	// if the mission is from volition, blit the volition icon
	if ((fb != NULL) && (fb->flags & FSB_FROM_VOLITION)) {
		return true;
	}
	return false;
}

void multi_create_list_blit_icons(int list_index, int y_start)
{
	multi_create_info *mcip;
	int max_index;

	// get a pointer to the list item
	max_index = (int)((Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) ? Multi_create_mission_list.size() - 1 : Multi_create_campaign_list.size() - 1);

	if ( (list_index < 0) || (list_index > max_index) ) {
		return;
	}

	if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
		mcip = &Multi_create_mission_list[list_index];
	} else {
		mcip = &Multi_create_campaign_list[list_index];
	}

	// blit the multiplayer type icons
	if(mcip->flags & MISSION_TYPE_MULTI_COOP){
		if(Multi_common_icons[MICON_COOP] >= 0){
			gr_set_bitmap(Multi_common_icons[MICON_COOP]);
			gr_bitmap(Mc_icon_type_coords[gr_screen.res][MC_X_COORD],y_start + Mc_icon_type_coords[gr_screen.res][MC_Y_COORD],GR_RESIZE_MENU);
		}
	} else if(mcip->flags & MISSION_TYPE_MULTI_TEAMS){
		if(Multi_common_icons[MICON_TVT] >= 0){
			gr_set_bitmap(Multi_common_icons[MICON_TVT]);
			gr_bitmap(Mc_icon_type_coords[gr_screen.res][MC_X_COORD],y_start + Mc_icon_type_coords[gr_screen.res][MC_Y_COORD],GR_RESIZE_MENU);
		}
	} else if(mcip->flags & MISSION_TYPE_MULTI_DOGFIGHT){
		if(Multi_common_icons[MICON_DOGFIGHT] >= 0){
			gr_set_bitmap(Multi_common_icons[MICON_DOGFIGHT]);
			gr_bitmap(Mc_icon_type_coords[gr_screen.res][MC_X_COORD],y_start + Mc_icon_type_coords[gr_screen.res][MC_Y_COORD],GR_RESIZE_MENU);
		}
	} 

	// if its a valid mission, blit the valid mission icon
	if(MULTI_IS_TRACKER_GAME && (mcip->valid_status == MVALID_STATUS_VALID)){
		if(Multi_common_icons[MICON_VALID] >= 0){
			gr_set_bitmap(Multi_common_icons[MICON_VALID]);
			gr_bitmap(Mc_icon_valid_coords[gr_screen.res][MC_X_COORD],y_start + Mc_icon_valid_coords[gr_screen.res][MC_Y_COORD],GR_RESIZE_MENU);
		}
	}

	// now see if it's a builtin mission
	// if the mission is from volition, blit the volition icon
	if (multi_is_item_builtin_volition(mcip->filename)) {
		if(Multi_common_icons[MICON_VOLITION] >= 0){
			gr_set_bitmap(Multi_common_icons[MICON_VOLITION]);
			gr_bitmap(Mc_icon_volition_coords[gr_screen.res][MC_X_COORD],y_start + Mc_icon_volition_coords[gr_screen.res][MC_Y_COORD],GR_RESIZE_MENU);
		}
	}	
}

void multi_create_accept_hit(int mode, int select_index)
{
	char selected_name[255];
	int start_campaign = 0;
    int popup_choice = 0;

	// make sure all players have finished joining
	if(!multi_netplayer_state_check(NETPLAYER_STATE_JOINED,1)){
		popup(PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR("Please wait until all clients have finished joining",788));
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return;
	} else {
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
	}	
	
	// do single mission stuff
	switch(mode){
	case MULTI_CREATE_SHOW_MISSIONS:	
		if (select_index != -1) {
			// set the netgame mode
			Netgame.campaign_mode = MP_SINGLE_MISSION;

			// setup various filenames and mission names
			strcpy(selected_name, Multi_create_mission_list[select_index].filename);
			strcpy_s( Game_current_mission_filename, selected_name);
			strcpy_s(Netgame.mission_name,selected_name);

			// NETLOG
			ml_printf(NOX("Starting single mission %s, with %d players"), Game_current_mission_filename, multi_num_players());
		} else {
			multi_common_add_notify(XSTR("No mission selected!",789));
			return ;
		}
		break;

	case MULTI_CREATE_SHOW_CAMPAIGNS:
		// do campaign related stuff	
		if (select_index != -1) {
			// set the netgame mode
			Netgame.campaign_mode = MP_CAMPAIGN;

			// start a campaign instead of a single mission
			strcpy(selected_name, Multi_create_campaign_list[select_index].filename);
			multi_campaign_start(selected_name);			
			start_campaign = 1;

			// NETLOG
			ml_printf(NOX("Starting campaign %s, with %d players"), selected_name, multi_num_players());
		} else {
			multi_common_add_notify(XSTR("No campaign selected!",790));
			return ;
		}
		break;
	}

	// if this is a team vs team situation, lock the players send a final team update
	if((Netgame.type_flags & NG_TYPE_TEAM) && (Net_player->flags & NETINFO_FLAG_AM_MASTER)){
		multi_team_host_lock_all();
		multi_team_send_update();
	}

	// coop game option validation checks
	if ( (Netgame.type_flags & NG_TYPE_COOP) && (Net_player->flags & NETINFO_FLAG_AM_MASTER) ) {
		// check for time limit
		if (Netgame.options.mission_time_limit != i2f(-1)) {
			popup_choice = popup(0, 3, POPUP_CANCEL, POPUP_YES, POPUP_NO,
								XSTR("A time limit is being used in a co-op game.\r\n"
									"  Select \'Cancel\' to go back to the mission select screen.\r\n"
									"  Select \'Yes\' to continue with this time limit.\r\n"
									"  Select \'No\' to continue without this time limit.", 1620));

			if (popup_choice == 0) {
				return;
			} else if (popup_choice == 2) {
				Netgame.options.mission_time_limit = i2f(-1);
			}
		}

		// check kill limit (NOTE: <= 0 is considered no limit)
		if ( (Netgame.options.kill_limit > 0) && (Netgame.options.kill_limit != 9999) ) {
			popup_choice = popup(0, 3, POPUP_CANCEL, POPUP_YES, POPUP_NO,
								XSTR("A kill limit is being used in a co-op game.\r\n"
									"  Select \'Cancel\' to go back to the mission select screen.\r\n"
									"  Select \'Yes\' to continue with this kill limit.\r\n"
									"  Select \'No\' to continue without this kill limit.", 1621));

			if (popup_choice == 0) {
				return;
			} else if (popup_choice == 2) {
				Netgame.options.kill_limit = 9999;
			}
		}
    }

	// if not on the standalone, move to the mission sync state which will take care of everything
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		Multi_sync_mode = MULTI_SYNC_PRE_BRIEFING;
		gameseq_post_event(GS_EVENT_MULTI_MISSION_SYNC);				
	} 
	// otherwise tell the standalone to do so
	else {
		// when the standalone receives this, he'll do the mission syncing himself
		send_mission_sync_packet(MULTI_SYNC_PRE_BRIEFING,start_campaign);
	}				
}

void multi_create_draw_filter_buttons()
{
	// highlight the correct filter button
	if ( Multi_create_filter == MISSION_TYPE_MULTI ){
		Multi_create_buttons[gr_screen.res][MC_SHOW_ALL].button.draw_forced(2);
	} else if ( Multi_create_filter == MISSION_TYPE_MULTI_COOP ) {
		Multi_create_buttons[gr_screen.res][MC_SHOW_ALL + 1].button.draw_forced(2);
	} else if ( Multi_create_filter == MISSION_TYPE_MULTI_TEAMS ) {
		Multi_create_buttons[gr_screen.res][MC_SHOW_ALL + 2].button.draw_forced(2);
	} else if ( Multi_create_filter == MISSION_TYPE_MULTI_DOGFIGHT ){
		Multi_create_buttons[gr_screen.res][MC_SHOW_ALL + 3].button.draw_forced(2);
	} else {
		Int3();
	}
}

void multi_create_set_selected_team(int team)
{	
	int player_index;
	
	// if we don't currently have a player selected, don't do anything
	if(!Multi_create_plist_select_flag){
		gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return;
	}
	gamesnd_play_iface(InterfaceSounds::USER_SELECT);

	// otherwise attempt to set the team for this guy	
	player_index = find_player_index(Multi_create_plist_select_id);
	if(player_index != -1){	
		multi_team_set_team(&Net_players[player_index],team);		
	}
}

void multi_create_handle_join(net_player * /*pl*/)
{
	// for now just play a bloop sound
	gamesnd_play_iface(InterfaceSounds::ICON_DROP_ON_WING);
}

// fill in net address of player the mouse is over, return player index (or -1 if none)
short multi_create_get_mouse_id()
{
	// determine where he clicked (y pixel value)
	int y,nth,idx;		
	Multi_create_player_select_button.get_mouse_pos(NULL,&y);

	// select things a little differently if we're in team vs. team or non-team vs. team mode			
	nth = (y / (gr_get_font_height() + 1));			
	if(Netgame.type_flags & NG_TYPE_TEAM){
		int player_index = -1;

		// look through all of team red first
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 0)){
				nth--;

				// if this is the _nth_ guy 
				if(nth < 0){
					player_index = idx;						
					break;
				}
			}
		}
			
		// if we still haven't found him yet, look through the green team
		if(player_index == -1){
			for(idx=0;idx<MAX_PLAYERS;idx++){					
				if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 1)){				
					nth--;
					// if this is the _nth_ guy 
					if(nth < 0){
						player_index = idx;						
						break;
					}
				}
			}
		}

		if(player_index != -1){
			return Net_players[player_index].player_id;
		}
	} else {
		// select the nth active player if possible, disregarding the standalone server
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
				nth--;

				// if this is the _nth_ guy 
				if(nth < 0){
					return Net_players[idx].player_id;					
				}				
			}
		}
	}				
	
	return -1;
}

void multi_create_select_to_filename(int select_index,char *filename)
{
	uint idx;

	// look through the mission list
	if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
		for (idx = 0; idx < Multi_create_mission_list.size(); idx++) {
			if (Multi_create_mission_list[idx].flags & Multi_create_filter) {
				select_index--;
			}

			// if we found the item
			if (select_index < 0) {
				strcpy(filename, Multi_create_mission_list[idx].filename);
				return;
			}
		}
	}
	// look through the campaign list
	else if (Multi_create_list_mode == MULTI_CREATE_SHOW_CAMPAIGNS) {
		for (idx = 0; idx < Multi_create_campaign_list.size(); idx++) {
			select_index--;

			// if we found the item
			if (select_index < 0) {
				strcpy(filename, Multi_create_campaign_list[idx].filename);
				return;
			}		
		}
	}

	strcpy(filename,"");
}

int multi_create_select_to_index(int select_index)
{
	uint idx;
	int lookup_index = 0;

	// look through the mission list
	if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
		for (idx = 0; idx < Multi_create_mission_list.size(); idx++) {
			if (Multi_create_mission_list[idx].flags & Multi_create_filter) {
				lookup_index++;
			} 

			// if we found the item
			if (select_index < lookup_index) {				
				return idx;
			}
		}
	}
	// look through the campaign list
	else if (Multi_create_list_mode == MULTI_CREATE_SHOW_CAMPAIGNS) {
		for (idx = 0; idx < Multi_create_campaign_list.size(); idx++) {
			select_index--;

			// if we found the item
			if (select_index < 0) {				
				return idx;
			}		
		}
	}

	return -1;
}

int multi_create_ok_to_commit(int select_index)
{
	int player_count, observer_count, idx;
	int notify_of_hacked_tbl = 0;
	char err_string[255];
	int found_hack;

	// if this is not a valid mission, let the player know	
	if (select_index < 0) {
		return 0;
	}

	// if we're playing with hacked tables (on PXO)
	if (MULTI_IS_TRACKER_GAME) {
		notify_of_hacked_tbl = 0;

		if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
			if ( game_hacked_data() ) {
				notify_of_hacked_tbl = 1;
			}
		} else if (Netgame.flags & NG_FLAG_HACKED_SHIPS_TBL) {
			notify_of_hacked_tbl = 1;
		}

		if (notify_of_hacked_tbl) {
			if (popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON, 2, XSTR("&Back", 995), XSTR("&Continue", 780), XSTR("You or the server you are playing on has a hacked ships.tbl. Your stats will not be updated on PXO", 1051)) <= 0) {
				return 0;
			}
		}
	}

	// if any of the players have hacked data
	found_hack = 0;
	for(idx=0; idx<MAX_PLAYERS; idx++){
		// look for hacked players
		if(MULTI_CONNECTED(Net_players[idx]) && (Net_players[idx].flags & NETINFO_FLAG_HAXOR)){
			// we found a hack
			found_hack = 1;

			// message everyone - haha
			if(Net_players[idx].m_player != NULL){
				sprintf(err_string, "%s %s", Net_players[idx].m_player->callsign, XSTR("has hacked tables/data", 1271)); 
			} else {
				sprintf(err_string, "somebody %s", XSTR("has hacked tables/data", 1271)); 
			}
			send_game_chat_packet(Net_player, err_string, MULTI_MSG_ALL, NULL, NULL, 1);
		}
	}
	// if we found a hacked set of data
	if(found_hack){
		// if we're on PXO
		if(MULTI_IS_TRACKER_GAME){
			// don't allow squad war matches to continue
			if(Netgame.type_flags & NG_TYPE_SW){
				// if this is squad war, don't allow it to continue			
				popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("One or more players has hacked data files. You cannot play a SquadWar match unless all clients have legal data", 1272));

				return 0;
			}
			// otherwise, warn the players that stats will not saved
			else {
				// if this is squad war, don't allow it to continue			
				if(popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON, 2, XSTR("&Back", 995), XSTR("&Continue", 780), XSTR("One or more players has hacked data files. If you continue, stats will not be stored at the end of the mission", 1273)) <= 0){
					return 0;
				}
			}
		}
		// non-pxo, just give a notice
		else {
			if(popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON, 2, XSTR("&Back", 995), XSTR("&Continue", 780), XSTR("One or more players has hacked data files", 1274)) <= 0){
				return 0;
			}
		}
	}

	// check to see that we don't have too many observers
	observer_count = multi_num_observers();
	if(observer_count > Netgame.options.max_observers){
		// print up the error string
		sprintf(err_string,XSTR("There are too many observers in the game\n\nMax : %d\nCurrently %d\n\nPlease dump a few",791),Netgame.options.max_observers,observer_count);

		popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, err_string);
		return 0;
	}

	// check to see that we have a valid # of players for the the # of ships in the game		
	player_count = multi_num_players();
	if(player_count > Netgame.max_players){
		// print up the error string
		sprintf(err_string,XSTR("There are too many players in the game\n\nMax : %d\nCurrently %d\n\nPlease dump a few", 792), Netgame.max_players,player_count);

		popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, err_string);
		return 0;
	}
	
	// check to see if teams are assigned properly in a team vs. team situation
	if(Netgame.type_flags & NG_TYPE_TEAM){
		if(!multi_team_ok_to_commit()){
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
			popup(PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("Teams and/or team captains are not assigned properly", 793));			
			return 0;
		}
	}	
	
	// if we're playing on the tracker
	if(MULTI_IS_TRACKER_GAME){
//#ifdef PXO_CHECK_VALID_MISSIONS		
		if ( (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) && (Multi_create_mission_list[select_index].valid_status != MVALID_STATUS_VALID) ) {
			if(popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON, 2, XSTR("&Back", 995), XSTR("&Continue", 780), XSTR("You have selected a mission which is either invalid or unknown to PXO. Your stats will not be saved if you continue",996)) <= 0){
				return 0;
			}
		}		
//#endif

		// non-squad war
		if(!(Netgame.type_flags & NG_TYPE_SW)){
			// if he is playing by himself, tell him stats will not be accepted
			if(multi_num_players() == 1){
				if(popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG, 2, XSTR("&Back", 995), XSTR("&Continue", 780), XSTR("Warning\n\nIf you start a PXO mission by yourself, your stats will not be updated", 997)) <= 0){
					return 0;
				}
			}
		}
		// squad war
		else {
			if ( !multi_sw_ok_to_commit() ) {
				return 0;
			}
		}
	}	
		
	return 1;
}

// returns an index into Multi_create_mission_list
int multi_create_lookup_mission(char *fname)
{
	uint idx;

	for (idx = 0; idx < Multi_create_mission_list.size(); idx++) {
		if ( !stricmp(fname, Multi_create_mission_list[idx].filename) ) {
			return idx;
		}
	}

	// couldn't find the mission
	return -1;
}

// returns an index into Multi_create_campaign_list
int multi_create_lookup_campaign(char *fname)
{
	uint idx;

	for (idx = 0; idx < Multi_create_campaign_list.size(); idx++) {
		if ( !stricmp(fname, Multi_create_campaign_list[idx].filename) ) {
			return idx;
		}
	}

	// couldn't find the campaign
	return -1;
}


void multi_create_refresh_pxo()
{
	// delete mvalid.cfg if it exists
	cf_delete(MULTI_VALID_MISSION_FILE, CF_TYPE_DATA);

	// refresh missions from the tracker
	multi_update_valid_missions();
}

void multi_create_sw_clicked()
{
	netgame_info ng_temp;
	netgame_info *ng;
	multi_create_info *mcip;

	int file_index = multi_create_select_to_index(Multi_create_list_select);

	if (file_index < 0) {
		Int3();

		if ( Multi_create_sw_checkbox.checked() ) {
			Multi_create_sw_checkbox.set_state(0);
		}

		return;
	}

	if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
		mcip = &Multi_create_mission_list[file_index];
	} else {
		mcip = &Multi_create_campaign_list[file_index];
	}

	// either a temporary netgame or the real one
	if(MULTIPLAYER_MASTER){
		ng = &Netgame;
	} else {
		ng_temp = Netgame;
		ng = &ng_temp;
	}

	// maybe switch squad war off
	if(!Multi_create_sw_checkbox.checked()){
		// if the mission selected is a coop mission, go back to coop mode

		if (mcip->flags & MISSION_TYPE_MULTI_TEAMS) {
			ng->type_flags = NG_TYPE_TVT;
		} else if (mcip->flags & MISSION_TYPE_MULTI_DOGFIGHT) {
			ng->type_flags = NG_TYPE_DOGFIGHT;
		} else {
			ng->type_flags = NG_TYPE_COOP;
		}
	}
	// switch squad war on
	else {
		// at this point we know its safe to switch squad war on
		ng->type_flags = NG_TYPE_SW;
	}

	// update 
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){		
		// update players 
		send_netgame_update_packet();			

		// update all machines about stuff like respawns, etc.
		multi_options_update_netgame();
	}
	// on the standalone
	else {
		// standalone will take care of polling the usertracker
		multi_options_update_mission(ng, Multi_create_list_mode == MULTI_CREATE_SHOW_CAMPAIGNS ? 1 : 0);
	}
}


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER HOST OPTIONS SCREEN
//

#define MULTI_HO_NUM_BUTTONS				12
#define MULTI_HO_NUM_RADIO_BUTTONS		10

//XSTR:OFF
// bitmaps defs
#define MULTI_HO_PALETTE				"InterfacePalette"

static const char *Multi_ho_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiHost",			// GR_640
	"2_MultiHost"			// GR_1024
};

static const char *Multi_ho_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiHost-M",			// GR_640
	"2_MultiHost-M"		// GR_1024
};

//XSTR:ON
UI_WINDOW Multi_ho_window;												// the window object for the join screen
UI_INPUTBOX Multi_ho_respawns;										// the # of respawns allowed in the game
UI_INPUTBOX Multi_ho_time_limit;										// mission time limit
UI_INPUTBOX Multi_ho_voice_wait;										// wait time between tokens
UI_INPUTBOX Multi_ho_kill_limit;										// kill limit in a furball mission
UI_INPUTBOX Multi_ho_obs;												// # of observers we'll allow
int Multi_ho_bitmap;														// the background bitmap

// constants for coordinate lookup
#define MULTI_HO_X_COORD			0
#define MULTI_HO_Y_COORD			1
#define MULTI_HO_W_COORD			2
#define MULTI_HO_H_COORD			3
#define MULTI_HO_TEXT_X_COORD		4
#define MULTI_HO_TEXT_Y_COORD		5

// button defs
#define MULTI_HO_MSG_RANK				0		// highest ranking players can do messaging
#define MULTI_HO_MSG_LEADER			1		// wing/team leaders can do messaging
#define MULTI_HO_MSG_ANY				2		// any player can do messaging
#define MULTI_HO_MSG_HOST				3		// only the host can do messaging
#define MULTI_HO_END_RANK				4		// highest rank can and host can end mission
#define MULTI_HO_END_LEADER			5		// wing/team leaders and host can end the mission
#define MULTI_HO_END_ANY				6		// any player can end the mission
#define MULTI_HO_END_HOST				7		// only host can end the mission
#define MULTI_HO_VOICE_ON				8		// voice toggled on
#define MULTI_HO_VOICE_OFF				9		// voice toggled off
#define MULTI_HO_HOST_MODIFIES		10		// only the host or team captains can modify ships/weapons in briefing
#define MULTI_HO_ACCEPT					11		// accept button

ui_button_info Multi_ho_buttons[GR_NUM_RESOLUTIONS][MULTI_HO_NUM_BUTTONS] = {	
	{ // GR_640
		// who is allowed to message
		ui_button_info("MH_00",	3,	160,	46,	166,	0),		// highest rank
		ui_button_info("MH_01",	3,	179,	46,	185,	1),		// team/wing leader
		ui_button_info("MH_02",	3,	196,	46,	203,	2),		// any
		ui_button_info("MH_03",	3,	214,	46,	220,	3),		// host
		
		// who is allowed to end the mission
		ui_button_info("MH_04",	3,	257,	46,	265,	4),		// highest rank
		ui_button_info("MH_05",	3,	276,	46,	283,	5),		// team/wing leader
		ui_button_info("MH_06",	3,	294,	46,	300,	6),		// any
		ui_button_info("MH_07",	3,	311,	46,	317,	7),		// host		

		// voice on/off button
		ui_button_info("MH_09",	542,	158,	545,	185,	9),	
		ui_button_info("MH_10",	598,	158,	604,	185,	10),	

		// host modifies ships
		ui_button_info("MH_13",	542,	377,	437,	363,	13),	

		// exit
		ui_button_info("MH_14",	572,	428,	580,	414,	14),	
	},
	{ // GR_1024
		// who is allowed to message
		ui_button_info("2_MH_00",	5,	256,	73,	269,	0),		// highest rank
		ui_button_info("2_MH_01",	5,	286,	73,	297,	1),		// team/wing leader
		ui_button_info("2_MH_02",	5,	314,	73,	325,	2),		// any
		ui_button_info("2_MH_03",	5,	341,	73,	352,	3),		// host
		
		// who is allowed to end the mission
		ui_button_info("2_MH_04",	5,	412,	73,	425,	4),		// highest rank
		ui_button_info("2_MH_05",	5,	442,	73,	452,	5),		// team/wing leader
		ui_button_info("2_MH_06",	5,	470,	73,	480,	6),		// any
		ui_button_info("2_MH_07",	5,	497,	73,	508,	7),		// host		

		// voice on/off button
		ui_button_info("2_MH_09",	867,	253,	872,	296,	9),	
		ui_button_info("2_MH_10",	957,	253,	966,	296,	10),	

		// host modifies ships
		ui_button_info("2_MH_13",	867,	603,	784,	581,	13),	

		// exit
		ui_button_info("2_MH_14",	916,	685,	925,	665,	14),	
	},
};
UI_XSTR Multi_ho_text[GR_NUM_RESOLUTIONS][MULTI_HO_NUM_BUTTONS] = {
	{ // GR_640
		{"Highest rank",					1280,	46,	166,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_MSG_RANK].button},
		{"Team / wing-leader",			1281, 46,	185,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_MSG_LEADER].button},
		{"Any",								1282, 46,	203,	UI_XSTR_COLOR_GREEN,	-1, &Multi_ho_buttons[0][MULTI_HO_MSG_ANY].button},
		{"Host",								1283,	46,	220,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_MSG_HOST].button},
		{"Highest rank",					1280,	46,	265,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_END_RANK].button},
		{"Team / wing-leader",			1281,	46,	283,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_END_LEADER].button},
		{"Any",								1282, 46,	300,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_END_ANY].button},
		{"Host",								1283,	46,	317,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_END_HOST].button},		
		{"On",								1285,	545,	185,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_VOICE_ON].button},
		{"Off",								1286,	604,	185,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_VOICE_OFF].button},
		{"Host modifies ships",			1287,	437,	363,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[0][MULTI_HO_HOST_MODIFIES].button},
		{"Exit",								1417,	572,	418,	UI_XSTR_COLOR_PINK,	-1, &Multi_ho_buttons[0][MULTI_HO_ACCEPT].button},
	},
	{ // GR_1024
		{"Highest rank",					1280,	62,	269,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_MSG_RANK].button},
		{"Team / wing-leader",			1281, 62,	297,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_MSG_LEADER].button},
		{"Any",								1282, 62,	325,	UI_XSTR_COLOR_GREEN,	-1, &Multi_ho_buttons[1][MULTI_HO_MSG_ANY].button},
		{"Host",								1283,	62,	352,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_MSG_HOST].button},
		{"Highest rank",					1280,	62,	425,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_END_RANK].button},
		{"Team / wing-leader",			1281,	62,	452,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_END_LEADER].button},
		{"Any",								1282, 62,	480,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_END_ANY].button},
		{"Host",								1283,	62,	508,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_END_HOST].button},		
		{"On",								1285,	877,	294,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_VOICE_ON].button},
		{"Off",								1286,	967,	293,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_VOICE_OFF].button},
		{"Host modifies ships",			1287,	869,	589,	UI_XSTR_COLOR_GREEN, -1, &Multi_ho_buttons[1][MULTI_HO_HOST_MODIFIES].button},
		{"Exit",								1417,	953,	672,	UI_XSTR_COLOR_PINK,	-1, &Multi_ho_buttons[1][MULTI_HO_ACCEPT].button},
	}
};

// radio button controls
#define MULTI_HO_NUM_RADIO_GROUPS		3
#define MULTI_HO_MSG_GROUP					0							// group dealing with squadmate messaging
#define MULTI_HO_END_GROUP					1							// group dealing with ending the mission
#define MULTI_HO_VOICE_GROUP				2							// group dealing with voice stuff
int Multi_ho_radio_groups[MULTI_HO_NUM_RADIO_GROUPS] = {		// currently selected button in the radio button group
	0,0,0
};
int Multi_ho_radio_info[MULTI_HO_NUM_RADIO_BUTTONS][3] = {	// info related to each of the radio buttons themselves
	// { group #, value, button id# }
	{0, 0, 0},				// highest ranking players can do messaging
	{0, 1, 1},				// wing/team leaders can do messaging
	{0, 2, 2},				// any player can do messaging
	{0, 3, 3},				// only host can do messaging	
	{1, 0, 4},				// highest rank and host can end the mission
	{1, 1, 5},				// team/wing leader can end the mission
	{1, 2, 6},				// any player can end the mission
	{1, 3, 7},				// only the host can end the mission
	{2, 0, 8},				// voice toggled on
	{2, 1, 9}				// voice toggled off
};

// slider controls
#define MULTI_HO_NUM_SLIDERS					3
#define MULTI_HO_SLIDER_VOICE_QOS			0						// voice quality of sound 
#define MULTI_HO_SLIDER_VOICE_DUR			1						// max duration of voice recording
#define MULTI_HO_SLIDER_SKILL					2						// skill level
struct ho_sliders {
	const char *filename;
	int x, y, xt, yt;
	int hotspot;
	int dot_w;
	int dots;
	UI_DOT_SLIDER_NEW slider;  // because we have a class inside this struct, we need the constructor below..

	ho_sliders(const char *name, int x1, int y1, int xt1, int yt1, int h, int _dot_w, int _dots) : filename(name), x(x1), y(y1), xt(xt1), yt(yt1), hotspot(h), dot_w(_dot_w), dots(_dots){}
};
ho_sliders Multi_ho_sliders[GR_NUM_RESOLUTIONS][MULTI_HO_NUM_SLIDERS] = {
	{ // GR_640
		ho_sliders("MH_11",	428,	214,	437,	199,	11,	19,	10),			// voice qos
		ho_sliders("MH_12",	428,	261,	437,	246,	12,	19,	10),			// voice duration
		ho_sliders("MH_08",	237,	454,	230,	411,	8,		36,	5),			// skill level
	},
	{ // GR_1024		
		ho_sliders("2_MH_11",	684,	343,	690,	323,	11,	32,	10),			// voice qos
		ho_sliders("2_MH_12",	685,	418,	837,	468,	12,	32,	10),			// voice duration
		ho_sliders("2_MH_08",	379,	727,	369,	663,	8,		60,	5),			// skill level
	}
};

int Multi_ho_mission_respawn;

int Multi_ho_host_modifies;

// whether or not any of the inputboxes on this screen had focus last frame
int Multi_ho_lastframe_input = 0;

// game information text areas

// ho titles
#define MULTI_HO_NUM_TITLES					14
UI_XSTR Multi_ho_titles[GR_NUM_RESOLUTIONS][MULTI_HO_NUM_TITLES] = {
	{ // GR_640
		{ "AI Orders",				1289,		32,	144, UI_XSTR_COLOR_GREEN, -1, NULL },		
		{ "End Mission",			1290,		32,	242, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Time Limit",			1291,		32,	347, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Min",						1292,		74,	362, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Respawn Limit",		1288,		32,	378, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Kill Limit",			1293,		32,	409, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Observers",				1294,		32,	441, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Skill Level",			1284,		230,	411, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Voice Transmission",	1295,		437,	144, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Voice Quality",		1296,		437,	199, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Message Duration",	1297,		437,	246, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "sec",						1522,		523,	292, UI_XSTR_COLOR_GREEN, -1, NULL },		
		{ "sec",						1523,		523,	332, UI_XSTR_COLOR_GREEN, -1, NULL },		
		{ "Voice Wait",			1298,		437,	313, UI_XSTR_COLOR_GREEN, -1, NULL },
	},
	{ // GR_1024		
		{ "AI Orders",				1289,		48,	238, UI_XSTR_COLOR_GREEN, -1, NULL },		
		{ "End Mission",			1290,		48,	394, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Time Limit",			1291,		50,	568, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Min",						1292,		119,	581, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Respawn Limit",		1288,		50,	618, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Kill Limit",			1293,		50,	668, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Observers",				1294,		50,	718, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Skill Level",			1284,		398,	670, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Voice Transmission",	1295,		869,	239, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Voice Quality",		1296,		690,	331, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Message Duration",	1297,		690,	405, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "sec",						1522,		837,	467, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "sec",						1523,		837,	534, UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Voice Wait",			1298,		742,	510, UI_XSTR_COLOR_GREEN, -1, NULL },
	}
};

// mission time limit input box
int Ho_time_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		36, 362, 36, 17
	},
	{ // GR_1024
		58, 581, 57, 27
	}
};

// furball kill limit input box
int Ho_kill_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		36, 425, 45, 17
	},
	{ // GR_1024
		58, 684, 72, 27
	}
};

// voice recording duration text display area
int Ho_vd_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		467, 292, 55, 15
	},
	{ // GR_1024
		750, 467, 85, 28
	}
};

// voice token wait input box
int Ho_vw_coords[GR_NUM_RESOLUTIONS][6] = {
	{ // GR_640
		467, 332, 55, 15
	},
	{ // GR_1024
		750, 534, 85, 28
	}
};

// observer count input box
int Ho_obs_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		36, 457, 45, 17
	},
	{ // GR_1024
		58, 733, 72, 27
	}
};

// skill text description area
int Ho_st_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		249, 435, 172, 10
	},
	{ // GR_1024
		403, 699, 172, 10
	}
};

// respawn input box
int Ho_rsp_coords[GR_NUM_RESOLUTIONS][6] = {
	{ // GR_640
		36, 394, 45, 17, 
	},
	{ // GR_1024
		58, 632, 72, 27
	}
};

// respawn max text area
int Ho_max_rsp_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		150, 378
	},
	{ // GR_1024
		190, 618
	}
};

// LOCAL function definitions
void multi_ho_check_buttons();
void multi_ho_button_pressed(int n);
void multi_ho_draw_radio_groups();
void multi_ho_accept_hit();
void multi_ho_get_options();
void multi_ho_apply_options();
void multi_ho_display_record_time();
int multi_ho_check_values();
void multi_ho_check_focus();
void multi_ho_blit_max_respawns();
void multi_ho_display_skill_level();

void multi_host_options_init()
{
	int idx;

	// create the interface window
	Multi_ho_window.create(0,0,gr_screen.max_w_unscaled,gr_screen.max_h_unscaled,0);
	Multi_ho_window.set_mask_bmap(Multi_ho_bitmap_mask_fname[gr_screen.res]);

	// load the background bitmap
	Multi_ho_bitmap = bm_load(Multi_ho_bitmap_fname[gr_screen.res]);
	if(Multi_ho_bitmap < 0){
		// we failed to load the bitmap - this is very bad
		Int3();
	}		

	// initialize the common notification messaging
	multi_common_notify_init();	

	// use the common interface palette
	multi_common_set_palette();	

	// create the interface buttons
	for(idx=0;idx<MULTI_HO_NUM_BUTTONS;idx++){
		// create the object
		Multi_ho_buttons[gr_screen.res][idx].button.create(&Multi_ho_window, "", Multi_ho_buttons[gr_screen.res][idx].x, Multi_ho_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

		// set the sound to play when highlighted
		Multi_ho_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

		// set the ani for the button
		Multi_ho_buttons[gr_screen.res][idx].button.set_bmaps(Multi_ho_buttons[gr_screen.res][idx].filename);

		// set the hotspot, ignoring the skill level button		
		Multi_ho_buttons[gr_screen.res][idx].button.link_hotspot(Multi_ho_buttons[gr_screen.res][idx].hotspot);

		// add xstr text
		Multi_ho_window.add_XSTR(&Multi_ho_text[gr_screen.res][idx]);
	}		

	// create misc text
	for(idx=0; idx<MULTI_HO_NUM_TITLES; idx++){
		Multi_ho_window.add_XSTR(&Multi_ho_titles[gr_screen.res][idx]);
	}

	// create the interface sliders
	for(idx=0; idx<MULTI_HO_NUM_SLIDERS; idx++){
		// create the object
		Multi_ho_sliders[gr_screen.res][idx].slider.create(&Multi_ho_window, Multi_ho_sliders[gr_screen.res][idx].x, Multi_ho_sliders[gr_screen.res][idx].y, Multi_ho_sliders[gr_screen.res][idx].dots, Multi_ho_sliders[gr_screen.res][idx].filename, Multi_ho_sliders[gr_screen.res][idx].hotspot, NULL, -1, -1, -1, NULL, -1, -1, -1, Multi_ho_sliders[gr_screen.res][idx].dot_w);
	}

	// create the respawn count input box
	Multi_ho_respawns.create(&Multi_ho_window,Ho_rsp_coords[gr_screen.res][MULTI_HO_X_COORD],Ho_rsp_coords[gr_screen.res][MULTI_HO_Y_COORD],Ho_rsp_coords[gr_screen.res][MULTI_HO_W_COORD],6,"",UI_INPUTBOX_FLAG_ESC_FOC | UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_NO_LETTERS,-1,&Color_bright);		
	// if we're in campaign mode, disable it
	if(Netgame.campaign_mode == MP_CAMPAIGN){
		Multi_ho_respawns.set_text(XSTR("NA",795));  // [[ Not applicable ]]
		Multi_ho_respawns.disable();
	} else {
		Multi_ho_respawns.set_valid_chars("0123456789");
	}

	// create the time limit input box
	Multi_ho_time_limit.create(&Multi_ho_window, Ho_time_coords[gr_screen.res][MULTI_HO_X_COORD], Ho_time_coords[gr_screen.res][MULTI_HO_Y_COORD], Ho_time_coords[gr_screen.res][MULTI_HO_W_COORD], 3, "", UI_INPUTBOX_FLAG_ESC_FOC | UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_NO_LETTERS, -1, &Color_bright);
	Multi_ho_time_limit.set_valid_chars("-0123456789");

	// create the voice token wait input box
	Multi_ho_voice_wait.create(&Multi_ho_window, Ho_vw_coords[gr_screen.res][MULTI_HO_X_COORD], Ho_vw_coords[gr_screen.res][MULTI_HO_Y_COORD], Ho_vw_coords[gr_screen.res][MULTI_HO_W_COORD], 1, "", UI_INPUTBOX_FLAG_ESC_FOC | UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_NO_LETTERS, -1, &Color_bright);
	Multi_ho_voice_wait.set_valid_chars("01243456789");

	// create the furball kill limit input box
	Multi_ho_kill_limit.create(&Multi_ho_window, Ho_kill_coords[gr_screen.res][MULTI_HO_X_COORD], Ho_kill_coords[gr_screen.res][MULTI_HO_Y_COORD], Ho_kill_coords[gr_screen.res][MULTI_HO_W_COORD], 4, "", UI_INPUTBOX_FLAG_ESC_FOC | UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_NO_LETTERS, -1, &Color_bright);
	Multi_ho_kill_limit.set_valid_chars("0123456789");

	// create the observer limit input box
	Multi_ho_obs.create(&Multi_ho_window, Ho_obs_coords[gr_screen.res][MULTI_HO_X_COORD], Ho_obs_coords[gr_screen.res][MULTI_HO_Y_COORD], Ho_obs_coords[gr_screen.res][MULTI_HO_W_COORD], 1, "", UI_INPUTBOX_FLAG_ESC_FOC | UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_NO_LETTERS, -1, &Color_bright);
	Multi_ho_obs.set_valid_chars("01234");	
	
	// load in the current netgame defaults
	multi_ho_get_options();

	// whether or not any of the inputboxes on this screen had focus last frame
	Multi_ho_lastframe_input = 0;	

	// get the # of respawns for the currently selected mission (if any)
	if(Multi_create_list_select != -1){
		int abs_index = multi_create_select_to_index(Multi_create_list_select);

		// if he has a valid mission selected
		if(abs_index >= 0){
			if (Multi_create_list_mode == MULTI_CREATE_SHOW_MISSIONS) {
				Multi_ho_mission_respawn = (int)Multi_create_mission_list[abs_index].respawn;
			} else {
				Multi_ho_mission_respawn = (int)Multi_create_campaign_list[abs_index].respawn;
			}
		} else {
			Multi_ho_mission_respawn = -1;
		}
	} else {
		Multi_ho_mission_respawn = -1;
	}
}

void multi_ho_update_sliders()
{
	// game skill slider
	if (Game_skill_level != Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_SKILL].slider.pos) {
		if ( !(Netgame.type_flags & NG_TYPE_TEAM) ){		
			Game_skill_level = Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_SKILL].slider.pos;
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		} else {	
			Game_skill_level = NUM_SKILL_LEVELS / 2;
		}
	}

	// get the voice qos options
	if (Netgame.options.voice_qos != (ubyte)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_QOS].slider.pos + 1)) {
		Netgame.options.voice_qos = (ubyte)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_QOS].slider.pos + 1);	
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
	}

	// get the voice duration options
	if (Netgame.options.voice_record_time != (int)(0.5f * (float)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos + 1) * 1000.0f)) {
		Netgame.options.voice_record_time = (int)(0.5f * (float)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos + 1) * 1000.0f);
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
	}

}

void multi_host_options_do()
{
	int k;	
	
	// process stuff
	k = Multi_ho_window.process();		
	chatbox_process(k);	

	// process any keypresses
	switch(k){
	case KEY_ESC :
		gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
		break;
	// same as ACCEPT
	case KEY_CTRLED + KEY_ENTER :	
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		multi_ho_accept_hit();
		break;
	}

	// process any button clicks
	multi_ho_check_buttons();	

	// update the sliders
	multi_ho_update_sliders();

	// make sure that the chatbox inputbox and any inputbox on this screen are mutually exclusive in terms of focus
	multi_ho_check_focus();

	// draw the background, etc
	gr_reset_clip();
	GR_MAYBE_CLEAR_RES(Multi_ho_bitmap);
	if(Multi_ho_bitmap != -1){
		gr_set_bitmap(Multi_ho_bitmap);
		gr_bitmap(0,0,GR_RESIZE_MENU);
	}
	Multi_ho_window.draw();
	
	// draw all the radio buttons properly
	multi_ho_draw_radio_groups();
			
	// display any pending notification messages
	multi_common_notify_do();		

	// display the voice record time settings
	multi_ho_display_record_time();	

	// maybe display the max # of respawns next to the respawn input box
	multi_ho_blit_max_respawns();

	// blit the proper skill level	
	multi_ho_display_skill_level();

	// blit the "host modifies button"
	if(Multi_ho_host_modifies){
		Multi_ho_buttons[gr_screen.res][MULTI_HO_HOST_MODIFIES].button.draw_forced(2);
	}

	// process and show the chatbox thingie	
	chatbox_render();

	// draw tooltips
	Multi_ho_window.draw_tooltip();	

	// display the voice status indicator
	multi_common_voice_display_status();

	// flip the buffer
	gr_flip();
}

void multi_host_options_close()
{
	// unload any bitmaps
	if(!bm_unload(Multi_ho_bitmap)){
		nprintf(("General","WARNING : could not unload background bitmap %s\n",Multi_ho_bitmap_fname[gr_screen.res]));
	}	
	
	// destroy the UI_WINDOW
	Multi_ho_window.destroy();
}

void multi_ho_check_buttons()
{
	int idx;
	for(idx=0;idx<MULTI_HO_NUM_BUTTONS;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_ho_buttons[gr_screen.res][idx].button.pressed()){
			multi_ho_button_pressed(idx);
			break;
		}
	}
}

void multi_ho_button_pressed(int n)
{
	int radio_index,idx;
	int x_pixel,y_pixel;

	// get the pixel position of the click
	Multi_ho_buttons[gr_screen.res][n].button.get_mouse_pos(&x_pixel,&y_pixel);
		
	switch(n){		
	// clicked on the accept button
	case MULTI_HO_ACCEPT:
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		multi_ho_accept_hit();
		return;	
	
	// clicked on the host/captains only modify button
	case MULTI_HO_HOST_MODIFIES:
		// toggle it on or off
		Multi_ho_host_modifies = !Multi_ho_host_modifies;
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		return;
	}

	// look through the radio buttons and see which one this corresponds to
	radio_index = -1;
	for(idx=0;idx<MULTI_HO_NUM_RADIO_BUTTONS;idx++){
		if(Multi_ho_radio_info[idx][2] == n){
			radio_index = idx;
			break;
		}
	}
	Assert(radio_index != -1);

	// check to see if a radio button was pressed
	if(radio_index < MULTI_HO_NUM_RADIO_BUTTONS){
		// see if this value is already picked for this radio group
		if(Multi_ho_radio_groups[Multi_ho_radio_info[radio_index][0]] != Multi_ho_radio_info[radio_index][1]){
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Multi_ho_radio_groups[Multi_ho_radio_info[radio_index][0]] = Multi_ho_radio_info[radio_index][1];
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
	}
}

void multi_ho_draw_radio_groups()
{
	int idx;
	
	// go through each item and draw it if it is the selected button in its respective group
	for(idx=0;idx<MULTI_HO_NUM_RADIO_BUTTONS;idx++){
		/// if this button is the currently selected one in its group
		if(Multi_ho_radio_info[idx][1] == Multi_ho_radio_groups[Multi_ho_radio_info[idx][0]]){
			Multi_ho_buttons[gr_screen.res][Multi_ho_radio_info[idx][2]].button.draw_forced(2);
		}
	}
}

void multi_ho_set_skill_level(int skill) {
	// set the skill level.  If in team vs. team mode, preserve the old setting before saving
	// the pilot file.  I'll bet that this doesn't work though because the pilot file gets
	// written in a bunch of locations....sigh.
	if (!(Netgame.type_flags & NG_TYPE_TEAM)) {
		Game_skill_level = skill;
	} else {
		Game_skill_level = NUM_SKILL_LEVELS / 2;
	}
}

// for the API to avoid including freespace.h
// Is this really just the game's global?? - Mjn
int multi_ho_get_skill_level()
{
	return Game_skill_level;
}

void multi_ho_accept_hit()
{
	char resp_str[10];

	// check the values in the input boxes
	if(!multi_ho_check_values()){
		return;
	}
	
	// zero out the netgame flags
	Netgame.flags = 0;
	
	// set default options
	Netgame.options.flags = (MSO_FLAG_INGAME_XFER | MSO_FLAG_ACCEPT_PIX);

	// set the squadmate messaging flags
	switch(Multi_ho_radio_groups[MULTI_HO_MSG_GROUP]){
	case 0 : 
		Netgame.options.squad_set = MSO_SQUAD_RANK;
		break;
	case 1 :
		Netgame.options.squad_set = MSO_SQUAD_LEADER;		
		break;
	case 2 :
		Netgame.options.squad_set = MSO_SQUAD_ANY;		
		break;
	case 3 :
		Netgame.options.squad_set = MSO_SQUAD_HOST;
		break;
	default : 
		Int3(); 
	}

	// set the end mission flags
	switch(Multi_ho_radio_groups[MULTI_HO_END_GROUP]){
	case 0 : 
		Netgame.options.endgame_set = MSO_END_RANK;		
		break;
	case 1 :
		Netgame.options.endgame_set = MSO_END_LEADER;		
		break;			
	case 2 : 
		Netgame.options.endgame_set = MSO_END_ANY;		
		break;
	case 3 :
		Netgame.options.endgame_set = MSO_END_HOST;		
		break;	
	default : 
		Int3(); 
	}
	
	// set the voice toggle
	switch(Multi_ho_radio_groups[MULTI_HO_VOICE_GROUP]){
	case 0 :
		Netgame.options.flags &= ~(MSO_FLAG_NO_VOICE);
		break;
	case 1 :
		Netgame.options.flags |= MSO_FLAG_NO_VOICE;
		break;
	default : 
		Int3();
	}	

	// get the voice qos options
	Netgame.options.voice_qos = (ubyte)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_QOS].slider.pos + 1);	

	// get the voice duration options
	Netgame.options.voice_record_time = (int)(0.5f * (float)(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos + 1) * 1000.0f);
	
	multi_ho_set_skill_level(Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_SKILL].slider.pos);

	// set the netgame respawn count
	// maybe warn the user that respawns will not be used for a campaign mission
	if(Netgame.campaign_mode == MP_SINGLE_MISSION){
		Multi_ho_respawns.get_text(resp_str);
		uint temp_respawn = (uint)atoi(resp_str);
		// if he currently has no mission selected, let the user set any # of respawns
		if((int)temp_respawn > Multi_ho_mission_respawn){
			if(Multi_ho_mission_respawn == -1){	
				Netgame.respawn = temp_respawn;		
				Netgame.options.respawn = temp_respawn;
			}
			// this should have been taken care of by the interface code
			else {
				Int3();
			}
		} else {	
			Netgame.options.respawn = temp_respawn;
			Netgame.respawn = temp_respawn;
		}
	}

	// get the mission time limit
	Multi_ho_time_limit.get_text(resp_str);
	int temp_time = atoi(resp_str);
	if(temp_time <= 0){
		Netgame.options.mission_time_limit = fl2f(-1.0f);
	} else if(temp_time > MULTI_HO_MAX_TIME_LIMIT){
		Int3();
	} else {
		Netgame.options.mission_time_limit = fl2f(60.0f * (float)temp_time);	
	}

	// get observer count options
	Multi_ho_obs.get_text(resp_str);
	int temp_obs = atoi(resp_str);
	if(temp_obs > MULTI_HO_MAX_OBS){
		Int3();
	} 
	Netgame.options.max_observers = (ubyte)temp_obs;	

	// get the furball kill limit
	Multi_ho_kill_limit.get_text(resp_str);
	int temp_kills = atoi(resp_str);
	if(temp_kills > MULTI_HO_MAX_KILL_LIMIT){
		Int3();
	}
	Netgame.options.kill_limit = temp_kills;

	// get the token wait limit
	Multi_ho_voice_wait.get_text(resp_str);
	int temp_wait = atoi(resp_str);
	if(temp_wait > MULTI_HO_MAX_TOKEN_WAIT){
		Int3();
	} 
	Netgame.options.voice_token_wait = (temp_wait * 1000);		

	// set the netgame option
	Netgame.options.skill_level = (ubyte)Game_skill_level;

	// get whether we're in host/captains only modify mode
	Netgame.options.flags &= ~(MSO_FLAG_SS_LEADERS);
	if(Multi_ho_host_modifies){
		Netgame.options.flags |= MSO_FLAG_SS_LEADERS;
	}	

	// store these values locally
	memcpy(&Player->m_local_options,&Net_player->p_info.options,sizeof(multi_local_options));
	memcpy(&Player->m_server_options,&Netgame.options,sizeof(multi_server_options));
	Pilot.save_player(Player);

	// apply any changes in settings (notify everyone of voice qos changes, etc)
	multi_ho_apply_options();

	// move back to the create game screen
	gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
}

void multi_ho_get_options()
{	
	char resp_str[10];
	
	// set the squadmate messaging buttons	
	switch(Netgame.options.squad_set){
	case MSO_SQUAD_RANK :		
		Multi_ho_radio_groups[MULTI_HO_MSG_GROUP] = 0;
		break;
	case MSO_SQUAD_LEADER:				
		Multi_ho_radio_groups[MULTI_HO_MSG_GROUP] = 1;
		break;
	case MSO_SQUAD_ANY:			
		Multi_ho_radio_groups[MULTI_HO_MSG_GROUP] = 2;
		break;
	case MSO_SQUAD_HOST:		
		Multi_ho_radio_groups[MULTI_HO_MSG_GROUP] = 3;
		break;
	default : 
		Int3();		
	}
	
	// set the mission end buttons	
	switch(Netgame.options.endgame_set){
	case MSO_END_RANK:			
		Multi_ho_radio_groups[MULTI_HO_END_GROUP] = 0;
		break;
	case MSO_END_LEADER:			
		Multi_ho_radio_groups[MULTI_HO_END_GROUP] = 1;
		break;
	case MSO_END_ANY:
		Multi_ho_radio_groups[MULTI_HO_END_GROUP] = 2;
		break;
	case MSO_END_HOST:
		Multi_ho_radio_groups[MULTI_HO_END_GROUP] = 3;
		break;
	default : 
		Int3();
	}			

	// set the voice toggle buttons
	if(Netgame.options.flags & MSO_FLAG_NO_VOICE){
		Multi_ho_radio_groups[MULTI_HO_VOICE_GROUP] = 1;
	} else {
		Multi_ho_radio_groups[MULTI_HO_VOICE_GROUP] = 0;
	}	

	// get the voice qos options
	Assert((Netgame.options.voice_qos >= 1) && (Netgame.options.voice_qos <= 10));
	Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_QOS].slider.pos = (Netgame.options.voice_qos - 1);

	// get the voice duration options
	Assert((Netgame.options.voice_record_time > 0) && (Netgame.options.voice_record_time <= MULTI_VOICE_MAX_TIME));
	Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos = ((int)((float)Netgame.options.voice_record_time / 500.0f)) - 1;	

	// get the current skill level
	Assert((Game_skill_level >= 0) && (Game_skill_level < NUM_SKILL_LEVELS));
	Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_SKILL].slider.pos = Game_skill_level;	

	// get the # of observers
	memset(resp_str,0,10);
	sprintf(resp_str,"%d",Netgame.options.max_observers);
	Multi_ho_obs.set_text(resp_str);

	// set the respawn count
	if(Netgame.campaign_mode == MP_SINGLE_MISSION){
		memset(resp_str,0,10);
		sprintf(resp_str,"%u",Netgame.respawn);
		Multi_ho_respawns.set_text(resp_str);	
	}

	// set the mission time limit
	memset(resp_str,0,10);
	float tl = f2fl(Netgame.options.mission_time_limit);
	sprintf(resp_str,"%d",(int)(tl / 60.0f));
	Multi_ho_time_limit.set_text(resp_str);

	// set the furball kill limit
	memset(resp_str,0,10);
	sprintf(resp_str,"%d",Netgame.options.kill_limit);
	Multi_ho_kill_limit.set_text(resp_str);

	// set the token wait time
	memset(resp_str,0,10);
	sprintf(resp_str,"%d",Netgame.options.voice_token_wait / 1000);
	Multi_ho_voice_wait.set_text(resp_str);	

	// get whether we're in host/captains only modify mode
	if(Netgame.options.flags & MSO_FLAG_SS_LEADERS){
		Multi_ho_host_modifies = 1;
	} else {
		Multi_ho_host_modifies = 0;
	}
}

void multi_ho_apply_options()
{
	// if the voice qos or duration has changed, apply the change
	multi_voice_maybe_update_vars(Netgame.options.voice_qos,Netgame.options.voice_record_time);		

	// send an options update
	multi_options_update_netgame();	
}

// display the voice record time settings
void multi_ho_display_record_time()
{
	char time_str[30];
	int full_seconds, half_seconds;

	// clear the string
	memset(time_str,0,30);

	// get the seconds
	full_seconds = (((Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos + 1) * 500) / 1000);
	
	// get the half-seconds
	half_seconds = ((((Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_VOICE_DUR].slider.pos + 1) * 500) % 1000) / 500) * 5;

	// format the string
	sprintf(time_str,"%d.%d",full_seconds,half_seconds);
	gr_set_color_fast(&Color_bright);
	gr_string(Ho_vd_coords[gr_screen.res][MULTI_HO_X_COORD],Ho_vd_coords[gr_screen.res][MULTI_HO_Y_COORD],time_str,GR_RESIZE_MENU);
}

int multi_ho_check_values()
{
	char val_txt[255];

	memset(val_txt,0,255);

	// check against respawn settings	
	if(Multi_ho_mission_respawn != -1){
		Multi_ho_respawns.get_text(val_txt);
		// if the value is invalid, let the user know
		if(atoi(val_txt) > Multi_ho_mission_respawn){
			memset(val_txt,0,255);
			sprintf(val_txt,XSTR("Warning\nRespawn count in greater than mission specified max (%d)",796),Multi_ho_mission_respawn);			
			popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG,1,POPUP_OK,val_txt);
			return 0;
		}
	}

	// check against mission time limit max
	Multi_ho_time_limit.get_text(val_txt);
	// if the value is invalid, force it to be valid
	if(atoi(val_txt) > MULTI_HO_MAX_TIME_LIMIT){
		memset(val_txt,0,255);
		sprintf(val_txt,XSTR("Warning\nMission time limit is greater than max allowed (%d)",797),MULTI_HO_MAX_TIME_LIMIT);		
		popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG,1,POPUP_OK,val_txt);
		return 0;
	}

	// check against max observer limit	
	Multi_ho_obs.get_text(val_txt);
	// if the value is invalid, force it to be valid
	if(atoi(val_txt) > MULTI_HO_MAX_OBS){
		memset(val_txt,0,255);
		sprintf(val_txt,XSTR("Warning\nObserver count is greater than max allowed (%d)",798),MULTI_HO_MAX_OBS);		
		popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG,1,POPUP_OK,val_txt);
		return 0;
	}

	// check against furball kill limit	
	Multi_ho_kill_limit.get_text(val_txt);
	// if the value is invalid, force it to be valid
	if(atoi(val_txt) > MULTI_HO_MAX_KILL_LIMIT){
		memset(val_txt,0,255);
		sprintf(val_txt,XSTR("Warning\nMission kill limit is greater than max allowed (%d)",799),MULTI_HO_MAX_KILL_LIMIT);		
		popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG,1,POPUP_OK,val_txt);
		return 0;
	}

	// check against the token wait limit	
	Multi_ho_voice_wait.get_text(val_txt);
	if(atoi(val_txt) > MULTI_HO_MAX_TOKEN_WAIT){
		memset(val_txt,0,255);
		sprintf(val_txt,XSTR("Warning\nvoice wait time is greater than max allowed (%d)",800),MULTI_HO_MAX_TOKEN_WAIT);		
		popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_RED | PF_TITLE_BIG,1,POPUP_OK,val_txt);
		return 0;
	}

	// all values are valid
	return 1;
}

void multi_ho_check_focus()
{
	// if an inputbox has been pressed (hit enter), lose its focus
	if (Multi_ho_respawns.pressed() || Multi_ho_time_limit.pressed() || Multi_ho_voice_wait.pressed() || Multi_ho_kill_limit.pressed() || Multi_ho_obs.pressed()) {
		Multi_ho_respawns.clear_focus();
		Multi_ho_time_limit.clear_focus();	
		Multi_ho_voice_wait.clear_focus();			
		Multi_ho_kill_limit.clear_focus();
		Multi_ho_obs.clear_focus();
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		chatbox_set_focus();
		Multi_ho_lastframe_input = 0;

	} else if(!Multi_ho_lastframe_input) {
		// if we didn't have focus last frame
		if(Multi_ho_respawns.has_focus() || Multi_ho_time_limit.has_focus() || Multi_ho_kill_limit.has_focus() || Multi_ho_voice_wait.has_focus() ){
			chatbox_lose_focus();

			Multi_ho_lastframe_input = 1;
		}	
	} 
	// if we _did_ have focus last frame
	else {
		// if we no longer have focus on any of the input boxes, set the focus on the chatbox
		if(!Multi_ho_respawns.has_focus() && !Multi_ho_time_limit.has_focus() && !Multi_ho_kill_limit.has_focus() && !Multi_ho_voice_wait.has_focus() && !chatbox_has_focus()){
			chatbox_set_focus();
		}			
		// if the chatbox now has focus, clear all focus from our inputboxes
		else if (chatbox_has_focus()) {
			Multi_ho_respawns.clear_focus();
			Multi_ho_time_limit.clear_focus();
			Multi_ho_kill_limit.clear_focus();
			Multi_ho_voice_wait.clear_focus();

			Multi_ho_lastframe_input = 0;
		}
	}
}

void multi_ho_blit_max_respawns()
{
	char string[50];
	
	// if we're in campaign mode, do nothing
	if(Netgame.campaign_mode == MP_CAMPAIGN){
		return;
	}
	
	// otherwise blit the max as specified by the current mission file	
	sprintf(string,"(%d)",Multi_ho_mission_respawn);	
	gr_set_color_fast(&Color_normal);
	gr_string(Ho_max_rsp_coords[gr_screen.res][MULTI_HO_X_COORD], Ho_max_rsp_coords[gr_screen.res][MULTI_HO_Y_COORD], string, GR_RESIZE_MENU);
}

void multi_ho_display_skill_level()
{
	int skill_level = Multi_ho_sliders[gr_screen.res][MULTI_HO_SLIDER_SKILL].slider.pos;

	// sanity
	Assert((skill_level >= 0) && (skill_level < NUM_SKILL_LEVELS));
	if((skill_level < 0) || (skill_level >= NUM_SKILL_LEVELS)){
		skill_level = 0;
	}

	gr_set_color_fast(&Color_bright);
	gr_string(Ho_st_coords[gr_screen.res][0], Ho_st_coords[gr_screen.res][1], Skill_level_names(skill_level, 1), GR_RESIZE_MENU);
}

// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER JOIN SCREEN 
//

#define MULTI_JW_NUM_BUTTONS	8

//XSTR:OFF
// bitmaps defs
#define MULTI_JW_PALETTE				"InterfacePalette"

static const char *Multi_jw_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiJoinWait",		// GR_640
	"2_MultiJoinWait"		// GR_1024
};

static const char *Multi_jw_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiJoinWait-M",		// GR_640
	"2_MultiJoinWait-M"		// GR_1024
};

//XSTR:ON

// button defs
#define MJW_SCROLL_PLAYERS_UP		0
#define MJW_SCROLL_PLAYERS_DOWN	1
#define MJW_TEAM0						2
#define MJW_TEAM1						3
#define MJW_PILOT_INFO				4
#define MJW_SCROLL_INFO_UP			5
#define MJW_SCROLL_INFO_DOWN		6
#define MJW_CANCEL					7

UI_WINDOW Multi_jw_window;												// the window object for the join screen
int Multi_jw_bitmap;														// the background bitmap

// constants for coordinate lookup
#define MJW_X_COORD 0
#define MJW_Y_COORD 1
#define MJW_W_COORD 2
#define MJW_H_COORD 3

ui_button_info Multi_jw_buttons[GR_NUM_RESOLUTIONS][MULTI_JW_NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info("MJW_00",	1,		24,	-1,	-1,	0),
		ui_button_info("MJW_01",	1,		66,	-1,	-1,	1),
		ui_button_info("MJW_02",	30,	244,	20,	272,	2),
		ui_button_info("MJW_03",	84,	244,	73,	272,	3),
		ui_button_info("MJW_04",	139,	242,	134,	272,	4),
		ui_button_info("MJW_05",	1,		406,	-1,	-1,	5),
		ui_button_info("MJW_06",	1,		447,	-1,	-1,	6),
		ui_button_info("MJW_07",	577,	428,	570,	414,	7),
	},
	{ // GR_1024
		ui_button_info("2_MJW_00",	2,		38,	-1,	-1,	0),
		ui_button_info("2_MJW_01",	2,		106,	-1,	-1,	1),
		ui_button_info("2_MJW_02",	48,	390,	47,	435,	2),
		ui_button_info("2_MJW_03",	134,	390,	133,	435,	3),
		ui_button_info("2_MJW_04",	223,	388,	225,	435,	4),
		ui_button_info("2_MJW_05",	2,		649,	-1,	-1,	5),
		ui_button_info("2_MJW_06",	2,		715,	-1,	-1,	6),
		ui_button_info("2_MJW_07",	923,	685,	931,	667,	7),
	}
};

#define MULTI_JW_NUM_TEXT			7

UI_XSTR Multi_jw_text[GR_NUM_RESOLUTIONS][MULTI_JW_NUM_TEXT] = {
	{ // GR_640
		{ "Team 1",				1308,		20,	272,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[0][MJW_TEAM0].button },
		{ "Team 2",				1309,		73,	272,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[0][MJW_TEAM1].button },
		{ "Pilot",				1310,		134,	272,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[0][MJW_PILOT_INFO].button },
		{ "Info",				1311,		134,	283,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[0][MJW_PILOT_INFO].button },
		{ "Cancel",				387,		570,	414,	UI_XSTR_COLOR_PINK, -1, &Multi_jw_buttons[0][MJW_CANCEL].button },
		{ "Players",			1269,		38,	8,		UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Choose Team",		1312,		27,	231,	UI_XSTR_COLOR_GREEN, -1, NULL },
	},
	{ // GR_1024
		{ "Team 1",				1308,		47,	435,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[1][MJW_TEAM0].button },
		{ "Team 2",				1309,		133,	435,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[1][MJW_TEAM1].button },
		{ "Pilot",				1310,		225,	435,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[1][MJW_PILOT_INFO].button },
		{ "Info",				1311,		225,	446,	UI_XSTR_COLOR_GREEN, -1, &Multi_jw_buttons[1][MJW_PILOT_INFO].button },
		{ "Cancel",				387,		931,	667,	UI_XSTR_COLOR_PINK, -1, &Multi_jw_buttons[1][MJW_CANCEL].button },
		{ "Players",			1269,		165,	12,	UI_XSTR_COLOR_GREEN, -1, NULL },
		{ "Choose Team",		1312,		45,	373,	UI_XSTR_COLOR_GREEN, -1, NULL },
	}
};

int Mjw_players_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		29, 18, 153, 210
	},
	{ // GR_1024
		46, 29, 254, 336
	}
};

int Mjw_mission_name_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		5, 380
	},
	{ // GR_1024
		47, 618
	}
};

// squad war checkbox
UI_CHECKBOX	Multi_jw_sw_checkbox;
const char *Multi_jw_sw_checkbox_fname[GR_NUM_RESOLUTIONS] = {
	"MC_SW_00",
	"MC_SW_00",
};
int Multi_jw_sw_checkbox_coords[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		6, 285
	},
	{ // GR_1024
		18, 450
	}
};
int Multi_jw_sw_checkbox_text[GR_NUM_RESOLUTIONS][2] = {
	{ // GR_640
		6, 305
	},
	{ // GR_640
		18, 470
	},
};


// player list control thingie defs
#define MULTI_JW_PLIST_MAX_DISPLAY		19
int Multi_jw_plist_select_flag;					// indicates whether we currently have a selected player
short Multi_jw_plist_select_id;				// id of the current selected player
UI_BUTTON Multi_jw_plist_select_button;		// for selecting a player

int Multi_jw_should_show_popup = 0;

// LOCAL function definitions
void multi_jw_check_buttons();
void multi_jw_button_pressed(int n);
void multi_jw_do_netstuff();
void multi_jw_scroll_players_up();
void multi_jw_scroll_players_down();
void multi_jw_plist_process();
void multi_jw_plist_blit_normal();
void multi_jw_plist_blit_team();
short multi_jw_get_mouse_id();

void multi_game_client_setup_init(bool API_Access)
{
	int idx;

	if (!API_Access) {
		// create the interface window
		Multi_jw_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
		Multi_jw_window.set_mask_bmap(Multi_jw_bitmap_mask_fname[gr_screen.res]);

		// load the background bitmap
		Multi_jw_bitmap = bm_load(Multi_jw_bitmap_fname[gr_screen.res]);
		if (Multi_jw_bitmap < 0) {
			// we failed to load the bitmap - this is very bad
			Int3();
		}

		// initialize the player list data
		Multi_jw_plist_select_flag = 0;
		Multi_jw_plist_select_id = -1;
	}
	// kill any old instances of the chatbox and create a new one
	chatbox_close(); //Need to pass API into these also
	chatbox_create(CHATBOX_FLAG_BIG | CHATBOX_FLAG_DRAW_BOX | CHATBOX_FLAG_BUTTONS);

	// initialize the common notification messaging
	multi_common_notify_init();

	// initialize the common mission info display area.
	multi_common_set_text("");

	// reset the multi description
	Multi_netgame_common_description.clear();
	Multi_received_mission_description.clear();

	// use the common interface palette
	multi_common_set_palette();	

	if (!API_Access) {
		// create the interface buttons
		for(idx=0; idx<MULTI_JW_NUM_BUTTONS; idx++){
			// create the object
			Multi_jw_buttons[gr_screen.res][idx].button.create(&Multi_jw_window, "", Multi_jw_buttons[gr_screen.res][idx].x, Multi_jw_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

			// set the sound to play when highlighted
			Multi_jw_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

			// set the ani for the button
			Multi_jw_buttons[gr_screen.res][idx].button.set_bmaps(Multi_jw_buttons[gr_screen.res][idx].filename);

			// set the hotspot
			Multi_jw_buttons[gr_screen.res][idx].button.link_hotspot(Multi_jw_buttons[gr_screen.res][idx].hotspot);
		}		

		// if this is a PXO game, enable the squadwar checkbox	
		Multi_jw_sw_checkbox.create(&Multi_jw_window, "", Multi_jw_sw_checkbox_coords[gr_screen.res][0], Multi_jw_sw_checkbox_coords[gr_screen.res][1], 0);
		Multi_jw_sw_checkbox.set_bmaps(Multi_jw_sw_checkbox_fname[gr_screen.res], 6, 0);
		Multi_jw_sw_checkbox.disable();
		if(!MULTI_IS_TRACKER_GAME){
			Multi_jw_sw_checkbox.hide();		
		}

		// create all xstrs
		for(idx=0; idx<MULTI_JW_NUM_TEXT; idx++){
			Multi_jw_window.add_XSTR(&Multi_jw_text[gr_screen.res][idx]);
		}
	
		// create the player select list button and hide it
		Multi_jw_plist_select_button.create(&Multi_jw_window, "", Mjw_players_coords[gr_screen.res][MJW_X_COORD], Mjw_players_coords[gr_screen.res][MJW_Y_COORD], Mjw_players_coords[gr_screen.res][MJW_W_COORD], Mjw_players_coords[gr_screen.res][MJW_H_COORD], 0, 1);
		Multi_jw_plist_select_button.hide();

		// set hotkeys
		Multi_jw_buttons[gr_screen.res][MJW_CANCEL].button.set_hotkey(KEY_ESC);	
	}
	// remove campaign flags
	Game_mode &= ~(GM_CAMPAIGN_MODE);

	// tell the server we have finished joining
	Net_player->state = NETPLAYER_STATE_JOINED;
	send_netplayer_update_packet();	

	// NETLOG
	ml_printf(NOX("Joined netgame %s"), Netgame.name);

	// send any appropriate files
	multi_data_send_my_junk();	
}

void multi_game_client_setup_do_frame(bool API_Access)
{
	int player_index;
	int k = chatbox_process();
	char mission_text[255];
	k = Multi_jw_window.process(k,0);	

	Multi_jw_should_show_popup = 0;

	if (!API_Access) {
		// process any button clicks
		multi_jw_check_buttons();
	}

	// do any network related stuff
	multi_jw_do_netstuff(); 		

	if (!API_Access) {
		// draw the background, etc
		gr_reset_clip();
		GR_MAYBE_CLEAR_RES(Multi_jw_bitmap);
		if (Multi_jw_bitmap != -1) {
			gr_set_bitmap(Multi_jw_bitmap);
			gr_bitmap(0, 0, GR_RESIZE_MENU);
		}

		// if we're not in team vs. team mode, don't draw the team buttons
		if (!(Netgame.type_flags & NG_TYPE_TEAM)) {
			Multi_jw_buttons[gr_screen.res][MJW_TEAM0].button.hide();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM1].button.hide();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM0].button.disable();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM1].button.disable();
		} else {
			Multi_jw_buttons[gr_screen.res][MJW_TEAM0].button.enable();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM1].button.enable();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM0].button.unhide();
			Multi_jw_buttons[gr_screen.res][MJW_TEAM1].button.unhide();
		}

		if (MULTI_IS_TRACKER_GAME) {
			// maybe check the squadwar button
			if (Netgame.type_flags & NG_TYPE_SW) {
				Multi_jw_sw_checkbox.set_state(1);
				gr_set_color_fast(&Color_bright);
			} else {
				Multi_jw_sw_checkbox.set_state(0);
				gr_set_color_fast(&Color_normal);
			}

			gr_string(Multi_jw_sw_checkbox_text[gr_screen.res][0],
				Multi_jw_sw_checkbox_text[gr_screen.res][1],
				"SquadWar",
				GR_RESIZE_MENU);
		}

		// draw the UI window
		Multi_jw_window.draw();

		// process and display the player list
		// NOTE : this must be done before the buttons are checked to insure that a player hasn't dropped
		multi_jw_plist_process();
		if (Netgame.type_flags & NG_TYPE_TEAM) {
			multi_jw_plist_blit_team();
		} else {
			multi_jw_plist_blit_normal();
		}

		// display any text in the info area
		multi_common_render_text();

		// display any pending notification messages
		multi_common_notify_do();

		// blit the mission filename if possible
		if (Netgame.campaign_mode) {
			if (Netgame.campaign_name[0] != '\0') {
				strcpy_s(mission_text, Netgame.campaign_name);

				if (Netgame.title[0] != '\0') {
					strcat_s(mission_text, ", ");
					strcat_s(mission_text, Netgame.title);
				}

				gr_set_color_fast(&Color_bright_white);
				gr_string(Mjw_mission_name_coords[gr_screen.res][MJW_X_COORD],
					Mjw_mission_name_coords[gr_screen.res][MJW_Y_COORD],
					mission_text,
					GR_RESIZE_MENU);
			}
		} else {
			if (Netgame.mission_name[0] != '\0') {
				strcpy_s(mission_text, Netgame.mission_name);

				if (Netgame.title[0] != '\0') {
					strcat_s(mission_text, ", ");
					strcat_s(mission_text, Netgame.title);
				}

				gr_set_color_fast(&Color_bright_white);
				gr_string(Mjw_mission_name_coords[gr_screen.res][MJW_X_COORD],
					Mjw_mission_name_coords[gr_screen.res][MJW_Y_COORD],
					mission_text,
					GR_RESIZE_MENU);
			}
		}

		// process and show the chatbox thingie
		chatbox_render();

		// draw tooltips
		Multi_jw_window.draw_tooltip();

		// display the voice status indicator
		multi_common_voice_display_status();

		// flip the buffer
		gr_flip();

		// if we're supposed to be displaying a pilot info popup
		if (Multi_jw_should_show_popup) {
			player_index = find_player_index(Multi_jw_plist_select_id);
			if (player_index != -1) {
				multi_pinfo_popup(&Net_players[player_index]);
			}
		}
	}
}

void multi_game_client_setup_close()
{
	// unload any bitmaps
	if(!bm_unload(Multi_jw_bitmap)){
		nprintf(("General","WARNING : could not unload background bitmap %s\n",Multi_jw_bitmap_fname[gr_screen.res]));
	}		

	// destroy the chatbox
	// chatbox_close();
	
	// destroy the UI_WINDOW
	Multi_jw_window.destroy();

	// play a sound.
	if(Netgame.game_state == NETGAME_STATE_MISSION_SYNC){
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
	}
}


void multi_jw_check_buttons()
{
	int idx;
	for(idx=0;idx<MULTI_JW_NUM_BUTTONS;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_jw_buttons[gr_screen.res][idx].button.pressed()){
			multi_jw_button_pressed(idx);
			break;
		}
	}
}

void multi_jw_button_pressed(int n)
{
	switch(n){	
	case MJW_CANCEL:
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_quit_game(PROMPT_CLIENT);		
		break;	
	case MJW_SCROLL_PLAYERS_UP:
		multi_jw_scroll_players_up();
		break;
	case MJW_SCROLL_PLAYERS_DOWN:
		multi_jw_scroll_players_down();
		break;	
	case MJW_SCROLL_INFO_UP:
		multi_common_scroll_text_up();
		break;
	case MJW_SCROLL_INFO_DOWN:
		multi_common_scroll_text_down();
		break;
	
	// request to set myself to team 0
	case MJW_TEAM0:
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_team_set_team(Net_player,0);
		break;

	// request to set myself to team 1
	case MJW_TEAM1:
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_team_set_team(Net_player,1);
		break;

	// pilot info popup
	case MJW_PILOT_INFO:
		Multi_jw_should_show_popup = 1;
		break;

	default :
		multi_common_add_notify(XSTR("Not implemented yet!",760));
		break;
	}
}

// do stuff like pinging servers, sending out requests, etc
void multi_jw_do_netstuff()
{
}

void multi_jw_scroll_players_up()
{
	gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
}

// scroll down through the player list
void multi_jw_scroll_players_down()
{	
	gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
}

void multi_jw_plist_process()
{
	int test_count,player_index,idx;
	
	// first determine if there are 0 players in the game. This should never happen since the host is _always_ in the game
	test_count = 0;
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
			test_count++;
		}
	}
	if(test_count <= 0){
		return;
	}
	
	// if we had a selected item but that player has left, select myself instead
	if(Multi_jw_plist_select_flag){
		player_index = find_player_index(Multi_jw_plist_select_id);
		if(player_index == -1){
			Multi_jw_plist_select_id = Net_player->player_id;						
		}
	} else {
		Multi_jw_plist_select_flag = 1;
		Multi_jw_plist_select_id = Net_player->player_id;		
	}
		
	// if the player has clicked somewhere in the player list area
	if(Multi_jw_plist_select_button.pressed()){
		short player_id;
	
		player_id = multi_jw_get_mouse_id();
		player_index = find_player_index(player_id);
		if(player_index != -1){
			Multi_jw_plist_select_id = player_id;
			Multi_jw_plist_select_flag = 1;
		}
	}
}

void multi_jw_plist_blit_normal()
{
	int idx;		
	char str[CALLSIGN_LEN+1];
	int y_start = Mjw_players_coords[gr_screen.res][MJW_Y_COORD];	
	int line_height = gr_get_font_height() + 1;
	int total_offset;

	// display all the players	
	for(idx=0;idx<MAX_PLAYERS;idx++){		
		// reset total offset
		total_offset = 0;

		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}		
			
			// make sure the string will fit, then display it
			strcpy_s(str,Net_players[idx].m_player->callsign);
			if(Net_players[idx].flags & NETINFO_FLAG_OBSERVER){
				strcat_s(str,"(0)");
			}
			font::force_fit_string(str,CALLSIGN_LEN,Mjw_players_coords[gr_screen.res][MJW_W_COORD] - total_offset);
			gr_string(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);

			y_start += line_height;			
		}
	}		
}

void multi_jw_plist_blit_team()
{
	int idx;		
	char str[CALLSIGN_LEN+1];
	int y_start = Mjw_players_coords[gr_screen.res][MJW_Y_COORD];	
	int line_height = gr_get_font_height() + 1;
	int total_offset;

	// always blit the proper team button based on _my_ team status
	if(Net_player->p_info.team == 0){
		Multi_jw_buttons[gr_screen.res][MJW_TEAM0].button.draw_forced(2);
	} else {
		Multi_jw_buttons[gr_screen.res][MJW_TEAM1].button.draw_forced(2);
	}

	// display all the red players first
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// reset total offset
		total_offset = 0;

		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 0)){
			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);					
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);					
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}		

			// blit the red team indicator
			if(Net_players[idx].flags & NETINFO_FLAG_TEAM_CAPTAIN){
				if(Multi_common_icons[MICON_TEAM0_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0_SELECT]);
					gr_bitmap(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start-2,GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM0_SELECT][0] + 1;
				}				
			} else {
				if(Multi_common_icons[MICON_TEAM0] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0]);
					gr_bitmap(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start-2,GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM0][0] + 1;
				}
			}

			// make sure the string will fit
			strcpy_s(str,Net_players[idx].m_player->callsign);
			font::force_fit_string(str,CALLSIGN_LEN,Mjw_players_coords[gr_screen.res][MJW_W_COORD] - total_offset);

			// display him in the correct half of the list depending on his team
			gr_string(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);
			y_start += line_height;
		}
	}	
	
	// display all the green players next
	for(idx=0;idx<MAX_PLAYERS;idx++){
		// reset total offset
		total_offset = 0;

		// count anyone except the standalone server (if applicable)
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 1)){
			// highlight him if he's the host			
			if(Net_players[idx].flags & NETINFO_FLAG_GAME_HOST){
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active_hi);				
				} else {
					gr_set_color_fast(&Color_bright);
				}
			} else {
				if(Multi_jw_plist_select_id == Net_players[idx].player_id){
					gr_set_color_fast(&Color_text_active);					
				} else {
					gr_set_color_fast(&Color_text_normal);
				}
			}			

			// blit the red team indicator
			if(Net_players[idx].flags & NETINFO_FLAG_TEAM_CAPTAIN){
				if(Multi_common_icons[MICON_TEAM1_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1_SELECT]);
					gr_bitmap(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start-2,GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM1_SELECT][0] + 1;
				}
			} else {
				if(Multi_common_icons[MICON_TEAM1] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1]);
					gr_bitmap(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start-2,GR_RESIZE_MENU);

					total_offset += Multi_common_icon_dims[MICON_TEAM1][0] + 1;
				}
			}

			// make sure the string will fit
			strcpy_s(str,Net_players[idx].m_player->callsign);
			if(Net_players[idx].flags & NETINFO_FLAG_OBSERVER){
				strcat_s(str,"(0)");
			}
			font::force_fit_string(str,CALLSIGN_LEN,Mjw_players_coords[gr_screen.res][MJW_W_COORD] - total_offset);

			// display him in the correct half of the list depending on his team
			gr_string(Mjw_players_coords[gr_screen.res][MJW_X_COORD] + total_offset,y_start,str,GR_RESIZE_MENU);
			y_start += line_height;
		}
	}			
}

void multi_jw_handle_join(net_player * /*pl*/)
{
	// for now just play a bloop sound
	gamesnd_play_iface(InterfaceSounds::ICON_DROP_ON_WING);
}

short multi_jw_get_mouse_id()
{
	// determine where he clicked (y pixel value)
	int y,nth,idx;		
	Multi_jw_plist_select_button.get_mouse_pos(NULL,&y);

	// select things a little differently if we're in team vs. team or non-team vs. team mode			
	nth = (y / (gr_get_font_height() + 1));			
	if(Netgame.type_flags & NG_TYPE_TEAM){
		int player_index = -1;

		// look through all of team red first
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 0)){				
				nth--;

				// if this is the _nth_ guy 
				if(nth < 0){
					player_index = idx;						
					break;
				}
			}
		}
			
		// if we still haven't found him yet, look through the green team
		if(player_index == -1){
			for(idx=0;idx<MAX_PLAYERS;idx++){
				if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].p_info.team == 1)){					
					nth--;
					// if this is the _nth_ guy 
					if(nth < 0){
						player_index = idx;						
						break;
					}
				}
			}
		}
		if(player_index != -1){
			return Net_players[idx].player_id;			
		}		
	} else {
		// select the nth active player if possible, disregarding the standalone server
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
				nth--;

				// if this is the _nth_ guy 
				if(nth < 0){
					return Net_players[idx].player_id;					
				}
			}
		}
		return -1;
	}				

	return -1;
}


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER WAIT/SYNCH SCREEN 
//

#define MULTI_SYNC_HOST_COUNT				4		// host uses 4 buttons (and sometimes 5)
#define MULTI_SYNC_CLIENT_COUNT			3		// client only uses 3 buttons

const char *Multi_sync_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"MultiSynch",		// GR_640
	"2_MultiSynch"		// GR_1024
};

const char *Multi_sync_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"MultiSynch-M",		// GR_640
	"2_MultiSynch-M"			// GR_1024
};

//XSTR:ON

// constants for coordinate lookup
#define MS_X_COORD 0
#define MS_Y_COORD 1
#define MS_W_COORD 2
#define MS_H_COORD 3

UI_WINDOW Multi_sync_window;												// the window object for the join screen
int Multi_sync_button_count;												// the # of buttons to use for this instance of mission sync
int Multi_sync_bitmap;														// the background bitmap

// button defs
#define MULTI_SYNC_NUM_BUTTONS			5
#define MS_SCROLL_INFO_UP					0
#define MS_SCROLL_INFO_DOWN				1
#define MS_CANCEL								2
#define MS_KICK								3
#define MS_LAUNCH								4
ui_button_info Multi_sync_buttons[GR_NUM_RESOLUTIONS][MULTI_SYNC_NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info("MS_00",		1,		404,	-1,	-1,	0),
		ui_button_info("MS_01",		1,		446,	-1,	-1,	1),
		ui_button_info("MS_03",		518,	426,	519,	416,	3),
		ui_button_info("MS_02",		469,	426,	479,	416,	2),		
		ui_button_info("MS_04",		571,	420,	577,	416,	4),
	},
	{ // GR_1024
		ui_button_info("2_MS_00",		2,		647,	-1,	-1,	0),
		ui_button_info("2_MS_01",		2,		713,	-1,	-1,	1),
		ui_button_info("2_MS_03",		829,	682,	831,	667,	3),
		ui_button_info("2_MS_02",		751,	682,	766,	667,	2),		
		ui_button_info("2_MS_04",		914,	672,	924,	667,	4),
	}
};

// text
#define MULTI_SYNC_NUM_TEXT				5
#define MST_KICK								0
#define MST_LAUNCH							2
UI_XSTR Multi_sync_text[GR_NUM_RESOLUTIONS][MULTI_SYNC_NUM_TEXT] = {
	{ // GR_640
		{ "Kick",		1266,		479,	416,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[0][MS_KICK].button },
		{ "Cancel",		387,		519,	416,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[0][MS_CANCEL].button },
		{ "Launch",		801,		577,	416,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[0][MS_LAUNCH].button },
		{ "Players",	1269,		23,	133,	UI_XSTR_COLOR_GREEN,	-1, NULL },
		{ "Status",		1304,		228,	133,	UI_XSTR_COLOR_GREEN,	-1, NULL }
	},
	{ // GR_1024
		{ "Kick",		1266,		766,	667,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[1][MS_KICK].button },
		{ "Cancel",		387,		831,	667,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[1][MS_CANCEL].button },
		{ "Launch",		801,		924,	667,	UI_XSTR_COLOR_PINK,	-1, &Multi_sync_buttons[1][MS_LAUNCH].button },
		{ "Players",	1269,		38,	214,	UI_XSTR_COLOR_GREEN,	-1, NULL },
		{ "Status",		1304,		366,	214,	UI_XSTR_COLOR_GREEN,	-1, NULL }
	}
};

// player name
int Ms_status_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		38, 150, 581, 220
	},
	{ // GR_1024
		38, 228, 958, 367
	}
};

// player status coords
int Ms_status2_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		228, 150, 391, 220
	},
	{ // GR_1024
		370, 228, 626, 367
	}
};

int Ms_cd_icon_offset[GR_NUM_RESOLUTIONS] = {
	10,		// GR_640
	10			// GR_1024
};

int Ms_team_icon_offset[GR_NUM_RESOLUTIONS] = {
	38,		// GR_640
	38			// GR_1024
};

// player currently selected, index into Net_players[]
int Multi_sync_player_select = -1;

// player list control thingie defs
#define MULTI_SYNC_PLIST_MAX_DISPLAY	15
int Multi_sync_plist_start;		// where to start displaying from
int Multi_sync_plist_count;		// how many we have

// list select button
UI_BUTTON Multi_sync_plist_button;

int Multi_sync_mode = -1;

#define MULTI_SYNC_COUNTDOWN_TIME			5				// in seconds
float Multi_sync_countdown_timer;
int Multi_sync_countdown = -1;

int Multi_launch_button_created;

//XSTR:OFF
// countdown animation timer
const char* Multi_sync_countdown_fname[GR_NUM_RESOLUTIONS] = {
	"Count",		// GR_640
	"2_Count"		// GR_1024
};

int Multi_sync_countdown_coords[GR_NUM_RESOLUTIONS][2] = {
	{
		0, 0		// GR_640
	},		
	{
		0, 0		// GR_1024
	}
};

//XSTR:ON

static generic_anim Multi_sync_countdown_anim;


// PREBRIEFING STUFF
// syncing flags used by the server
int Mission_sync_flags = 0;
#define MS_FLAG_SENT_FILESIG			(1<<0)	// sent filesig requests
#define MS_FLAG_SENT_LOAD				(1<<1)	// sent load packets
#define MS_FLAG_PUSHED_BRIEFING		(1<<2)	// pushed everyone else into the briefing
#define MS_FLAG_POST_DATA				(1<<3)	// sent the post data block
#define MS_FLAG_WSS_SLOTS				(1<<4)	// all players have received wss slot data
#define MS_FLAG_PSETTINGS				(1<<5)	// send the player settings packet
#define MS_FLAG_MT_STATS_START		(1<<6)	// server has started getting player stats from the tracker
#define MS_FLAG_MT_STATS_DONE			(1<<7)	// server has finished getting player stats from the tracker (success or fail)
#define MS_FLAG_TS_SLOTS				(1<<8)	// team/ship slots have been sent
#define MS_FLAG_DATA_DONE				(1<<9)	// done transferring all necessary data
#define MS_FLAG_CAMP_DONE				(1<<10)	// send campaign pool/goal/event stuff

// POSTBRIEFING STUFF
UI_TIMESTAMP Multi_state_timestamp;
int Multi_sync_launch_pressed;

// LOCAL function definitions
void multi_sync_check_buttons();
void multi_sync_button_pressed(int n);
void multi_sync_scroll_info_up();
void multi_sync_scroll_info_down();
void multi_sync_display_name(const char *name,int index,int np_index);		// display info on the left hand portion of the status window thingie
void multi_sync_display_status(const char *status,int index);					// display info on the right hand portion of the status window thingie
void multi_sync_force_start_pre();
void multi_sync_force_start_post();
void multi_sync_launch();
void multi_sync_create_launch_button();
void multi_sync_blit_screen_all();
void multi_sync_handle_plist();

void multi_sync_common_init(bool API_Access);
void multi_sync_common_do();
void multi_sync_common_close();

void multi_sync_pre_init();
void multi_sync_pre_do(bool API_Access);
void multi_sync_pre_close();

void multi_sync_post_init(bool API_Access);
void multi_sync_post_do(bool API_Access);
void multi_sync_post_close(bool API_Access);

int Sync_test = 1;


// perform the correct init functions
void multi_sync_init(bool API_Access)
{	
	Multi_sync_countdown = -1;

	Sync_test = 1;

	// reset all timestamp
	multi_reset_timestamps();

	if(!(Game_mode & GM_STANDALONE_SERVER)){
		multi_sync_common_init(API_Access);
	}
	
	switch(Multi_sync_mode){
	case MULTI_SYNC_PRE_BRIEFING:
		multi_sync_pre_init();
		break;
	case MULTI_SYNC_POST_BRIEFING:
		multi_sync_post_init(API_Access);
		break;
	case MULTI_SYNC_INGAME:
		multi_ingame_sync_init();
		break;
	}
}

// perform the correct do frame functions
void multi_sync_do(bool API_Access)
{
	if(!(Game_mode & GM_STANDALONE_SERVER) && !API_Access){
		multi_sync_common_do(); //Don't need this for the API
	}

	// if the netgame is ending, don't do any sync processing
	if(multi_endgame_ending()){
		return;
	}

	// process appropriateliy
	switch(Multi_sync_mode){
	case MULTI_SYNC_PRE_BRIEFING:		
		multi_sync_pre_do(API_Access);		
		break;
	case MULTI_SYNC_POST_BRIEFING:
		multi_sync_post_do(API_Access);
		break;
	case MULTI_SYNC_INGAME:
		multi_ingame_sync_do();

		if (!API_Access) {
			gr_reset_clip();
			GR_MAYBE_CLEAR_RES(Multi_sync_bitmap);
			if (Multi_sync_bitmap != -1) {
				gr_set_bitmap(Multi_sync_bitmap);
				gr_bitmap(0, 0, GR_RESIZE_MENU);
			}
			Multi_sync_window.draw();

			multi_sync_blit_screen_all();

			gr_flip();
		}
		break;
	}	
}

// perform the correct close functions
void multi_sync_close(bool API_Access)
{
	switch(Multi_sync_mode){
	case MULTI_SYNC_PRE_BRIEFING:
		multi_sync_pre_close();
		break;
	case MULTI_SYNC_POST_BRIEFING:
		multi_sync_post_close(API_Access);
		break;
	case MULTI_SYNC_INGAME:
		multi_ingame_sync_close();
		break;
	}
	
	if(!(Game_mode & GM_STANDALONE_SERVER) && !API_Access){
		multi_sync_common_close();
	}
}

const char *multi_sync_tooltip_handler(const char *str)
{
	if (!stricmp(str, NOX("@launch"))) {
		if (Multi_launch_button_created){
			return XSTR("Launch",801);
		}
	}

	return NULL;
}

void multi_sync_common_init(bool API_Access)
{
	int idx;

	if (!API_Access) {
		// create the interface window
		Multi_sync_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
		Multi_sync_window.set_mask_bmap(Multi_sync_bitmap_mask_fname[gr_screen.res]);
		Multi_sync_window.tooltip_handler = multi_sync_tooltip_handler;

		// load the background bitmap
		Multi_sync_bitmap = bm_load(Multi_sync_bitmap_fname[gr_screen.res]);
		if (Multi_sync_bitmap < 0) {
			// we failed to load the bitmap - this is very bad
			Int3();
		}

		// initialize the player list data
		Multi_sync_plist_start = 0;
		Multi_sync_plist_count = 1; // we can pretty safely assume that there's one player in the game - me.

		Multi_launch_button_created = 0;
	}
	// create the chatbox thingie	(shouldn't be necesary to do this, but we'll put it in for good measure)
	chatbox_create(); //Need to pass API_Access into this

	// force the chatbox to be small
	chatbox_force_small();

	// initialize the common notification messaging
	multi_common_notify_init();

	// initialize the common mission info display area.
	multi_common_set_text("");	

	// use the common interface palette
	multi_common_set_palette();

	// don't select any player yet.
	Multi_sync_player_select = -1;
	
	if (!API_Access){
		// determine how many of the 5 buttons to create
		if(Net_player->flags & NETINFO_FLAG_GAME_HOST){
			Multi_sync_button_count = MULTI_SYNC_HOST_COUNT;		
		} else {
			Multi_sync_button_count = MULTI_SYNC_CLIENT_COUNT;
		}
		// create the interface buttons	
		for(idx=0; idx<Multi_sync_button_count; idx++){
			// create the object
			Multi_sync_buttons[gr_screen.res][idx].button.create(&Multi_sync_window, "", Multi_sync_buttons[gr_screen.res][idx].x, Multi_sync_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

			// set the sound to play when highlighted
			Multi_sync_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

			// set the ani for the button
			// this wierdness is necessary because cancel and kick buttons aren't drawn on the background bitmap,
			//   so we have to load in frame 0, too (the file should exist)
			if ((idx == MS_CANCEL) || (idx == MS_KICK) || (idx == MS_LAUNCH)) {
				Multi_sync_buttons[gr_screen.res][idx].button.set_bmaps(Multi_sync_buttons[gr_screen.res][idx].filename, 3, 0);
			} else {
				Multi_sync_buttons[gr_screen.res][idx].button.set_bmaps(Multi_sync_buttons[gr_screen.res][idx].filename);
			}

			// set the hotspot
			Multi_sync_buttons[gr_screen.res][idx].button.link_hotspot(Multi_sync_buttons[gr_screen.res][idx].hotspot);
		}		

		// add xstrs
		for(idx=0; idx<MULTI_SYNC_NUM_TEXT; idx++) {
			// don't create the "launch" button text just yet
			if(idx == MST_LAUNCH) {
				continue;
			}
			// multiplayer clients should ignore the kick button
			if(!MULTIPLAYER_MASTER && !MULTIPLAYER_HOST && (idx == MST_KICK)) {
				continue;
			}

			Multi_sync_window.add_XSTR(&Multi_sync_text[gr_screen.res][idx]);
		}

		// create the player list select button and hide it
		Multi_sync_plist_button.create(&Multi_sync_window, "", Ms_status_coords[gr_screen.res][MS_X_COORD], Ms_status_coords[gr_screen.res][MS_Y_COORD], Ms_status_coords[gr_screen.res][MS_W_COORD], Ms_status_coords[gr_screen.res][MS_H_COORD], 0, 1);
		Multi_sync_plist_button.hide();

		// set up hotkeys for certain common functions
		Multi_sync_buttons[gr_screen.res][MS_CANCEL].button.set_hotkey(KEY_ESC);
	}
}

void multi_sync_common_do()
{	
	int k = chatbox_process();
	k = Multi_sync_window.process(k);	

	// process the player list
	multi_sync_handle_plist();

	// process any button clicks
	multi_sync_check_buttons();	

	// process any keypresses
	switch(k){
	case KEY_ESC :
		// Sync_test = 1;
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_quit_game(PROMPT_ALL);		
		break;	
	}				
}

void multi_sync_common_close()
{
	// unload any bitmaps
	if(!bm_unload(Multi_sync_bitmap)){
		nprintf(("General","WARNING : could not unload background bitmap %s\n",Multi_sync_bitmap_fname[gr_screen.res]));
	}	
	
	// destroy the UI_WINDOW
	Multi_sync_window.destroy();
}

SCP_string multi_sync_get_state_string(net_player* player)
{
	SCP_string txt;
	int state = player->state;
	// if we're ingame joining, show all other players except myself as "playing"
	if ((Net_player != NULL) && (player != Net_player) &&
		((Multi_sync_mode == MULTI_SYNC_INGAME) || (Net_player->flags & NETINFO_FLAG_INGAME_JOIN))) {
		state = NETPLAYER_STATE_IN_MISSION;
	}

	switch (state) {
	case NETPLAYER_STATE_MISSION_LOADING:
		txt = XSTR("Mission Loading", 802);
		break;
	case NETPLAYER_STATE_INGAME_SHIP_SELECT: // I don't think its possible to see this state, but...
		txt = XSTR("Ingame Ship Select", 803);
		break;
	case NETPLAYER_STATE_DEBRIEF:
		txt = XSTR("Debriefing", 804);
		break;
	case NETPLAYER_STATE_MISSION_SYNC:
		txt = XSTR("Mission Sync", 805);
		break;
	case NETPLAYER_STATE_JOINING:
		txt = XSTR("Joining", 806);
		break;
	case NETPLAYER_STATE_JOINED:
		txt = XSTR("Joined", 807);
		break;
	case NETPLAYER_STATE_SLOT_ACK:
		txt = XSTR("Slot Ack", 808);
		break;
	case NETPLAYER_STATE_BRIEFING:
		txt = XSTR("Briefing", 765);
		break;
	case NETPLAYER_STATE_SHIP_SELECT:
		txt = XSTR("Ship Select", 809);
		break;
	case NETPLAYER_STATE_WEAPON_SELECT:
		txt = XSTR("Weapon Select", 810);
		break;
	case NETPLAYER_STATE_WAITING:
		txt = XSTR("Waiting", 811);
		break;
	case NETPLAYER_STATE_IN_MISSION:
		txt = XSTR("In Mission", 812);
		break;
	case NETPLAYER_STATE_MISSION_LOADED:
		txt = XSTR("Mission Loaded", 813);
		break;
	case NETPLAYER_STATE_DATA_LOAD:
		txt = XSTR("Data loading", 814);
		break;
	case NETPLAYER_STATE_SETTINGS_ACK:
		txt = XSTR("Ready To Enter Mission", 815);
		break;
	case NETPLAYER_STATE_INGAME_SHIPS:
		txt = XSTR("Ingame Ships Packet Ack", 816);
		break;
	case NETPLAYER_STATE_INGAME_WINGS:
		txt = XSTR("Ingame Wings Packet Ack", 817);
		break;
	case NETPLAYER_STATE_INGAME_RPTS:
		txt = XSTR("Ingame Respawn Points Ack", 818);
		break;
	case NETPLAYER_STATE_SLOTS_ACK:
		txt = XSTR("Ingame Weapon Slots Ack", 819);
		break;
	case NETPLAYER_STATE_POST_DATA_ACK:
		txt = XSTR("Post Briefing Data Block Ack", 820);
		break;
	case NETPLAYER_STATE_FLAG_ACK:
		txt = XSTR("Flags Ack", 821);
		break;
	case NETPLAYER_STATE_MT_STATS:
		txt = XSTR("Parallax Online Stats Updating", 822);
		break;
	case NETPLAYER_STATE_WSS_ACK:
		txt = XSTR("Weapon Slots Ack", 823);
		break;
	case NETPLAYER_STATE_HOST_SETUP:
		txt = XSTR("Host setup", 824);
		break;
	case NETPLAYER_STATE_DEBRIEF_ACCEPT:
		txt = XSTR("Debrief accept", 825);
		break;
	case NETPLAYER_STATE_DEBRIEF_REPLAY:
		txt = XSTR("Debrief replay", 826);
		break;
	case NETPLAYER_STATE_CPOOL_ACK:
		txt = XSTR("Campaign ship/weapon ack", 827);
		break;
	case NETPLAYER_STATE_MISSION_XFER:
		// server should display the pct completion of all clients
		if (Net_player != nullptr && Net_player->flags & NETINFO_FLAG_AM_MASTER) {
			if (player->s_info.xfer_handle != -1) {
				float pct_complete = multi_xfer_pct_complete(player->s_info.xfer_handle);

				// if we've got a valid xfer handle
				if ((pct_complete >= 0.0) && (pct_complete <= 1.0)) {
					sprintf(txt, XSTR("Mission file xfer %d%%", 828), static_cast<int>(pct_complete * 100.0f));
				}
				// otherwise
				else {
					txt = XSTR("Mission file xfer", 829);
				}
			} else {
				txt = XSTR("Mission file xfer", 829);
			}
		}
		// clients should display only for themselves (which is the only thing they know)
		else {
			// if we've got a valid file xfer handle
			if ((player == Net_player) && (Net_player->s_info.xfer_handle != -1)) {
				float pct_complete = multi_xfer_pct_complete(Net_player->s_info.xfer_handle);

				// if we've got a valid xfer handle
				if ((pct_complete >= 0.0) && (pct_complete <= 1.0)) {
					sprintf(txt, XSTR("Mission file xfer %d%%", 828), static_cast<int>(pct_complete * 100.0f));
				}
				// otherwise
				else {
					txt = XSTR("Mission file xfer", 829);
				}
			}
			// otherwise
			else {
				txt = XSTR("Mission file xfer", 829);
			}
		}
		break;
	case NETPLAYER_STATE_FICTION_VIEWER:
		txt = XSTR("Fiction Viewer", -1); // XSTR ID?
		break;
	case NETPLAYER_STATE_CUTSCENE:
		txt = XSTR("Cutscene", -1); // XSTR ID?
		break;
	case NETPLAYER_STATE_CMD_BRIEFING:
		txt = XSTR("Command Briefing", -1); // XSTR ID?
		break;
	case NETPLAYER_STATE_RED_ALERT:
		txt = XSTR("Red Alert", -1); // XSTR ID?
		break;
	default:
		nprintf(("Network", "Unhandled player state : %d !\n", player->state));
		txt = XSTR("Unknown", 433); 
		break;
	}

	return txt;
}

void multi_sync_blit_screen_all()
{
	int count,idx;
	
	// display any text in the info area
	multi_common_render_text();

	// display any pending notification messages
	multi_common_notify_do();
	
	// display any info about visible players
	count = 0;	
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
			// display his name and status
			multi_sync_display_name(Net_players[idx].m_player->callsign,count,idx);

			multi_sync_display_status(multi_sync_get_state_string(&Net_players[idx]).c_str(), count);
			count++;
		}
	}	

	// display the mission start countdown timer (if any)
	//anim_render_all(GS_STATE_MULTI_MISSION_SYNC,flFrametime);
	if((gameseq_get_state() == GS_STATE_MULTI_MISSION_SYNC && Multi_sync_countdown_timer > -1.0f) || (Multi_sync_countdown != -1))
		generic_anim_render(&Multi_sync_countdown_anim, flFrametime, Multi_sync_countdown_coords[gr_screen.res][MS_X_COORD], Multi_sync_countdown_coords[gr_screen.res][MS_Y_COORD], true);


	// process and show the chatbox thingie	
	chatbox_render();

	// draw tooltips
	Multi_sync_window.draw_tooltip();

	// display the voice status indicator
	multi_common_voice_display_status();
}

void multi_sync_check_buttons()
{
	int idx;
	for(idx=0;idx<Multi_sync_button_count;idx++){
		// we only really need to check for one button pressed at a time, so we can break after 
		// finding one.
		if(Multi_sync_buttons[gr_screen.res][idx].button.pressed()){
			multi_sync_button_pressed(idx);
			break;
		}
	}
}

void multi_sync_button_pressed(int n)
{
	switch(n){	
	// exit the game
	case MS_CANCEL:
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		multi_quit_game(PROMPT_ALL);		
		break;	
	
	// scroll the info box up
	case MS_SCROLL_INFO_UP:
		multi_common_scroll_text_up();		
		break;
	
	// scroll the info box down
	case MS_SCROLL_INFO_DOWN:
		multi_common_scroll_text_down();
		break;	

	// KICK (host only)
	case MS_KICK:
		// if we have a currently selected player, kick him
		if(Multi_sync_player_select >= 0){
			multi_kick_player(Multi_sync_player_select);
		}
		break;
	
	// start the final launch countdown (post-sync only)
	case MS_LAUNCH:
		multi_sync_start_countdown();
		break;
	
	// doesn't do anything
	default :
		Int3();		
	}
}

void multi_sync_pre_init()
{
	int idx;

	Netgame.game_state = NETGAME_STATE_MISSION_SYNC;

	/* 	if we're in teamplay mode, always force skill level to be medium
	Karajorma - disabling cause it's just plain idiotic! if people want to play on insane let them

	if((Netgame.type_flags & NG_TYPE_TEAM) && (Net_player->flags & NETINFO_FLAG_GAME_HOST)){
		Netgame.options.skill_level = NUM_SKILL_LEVELS / 2;
		Game_skill_level = NUM_SKILL_LEVELS / 2;
		multi_options_update_netgame();
	}
	*/

	// notify everyone of when we get here
	if(!(Game_mode & GM_STANDALONE_SERVER)){
		Net_player->state = NETPLAYER_STATE_MISSION_SYNC;
		send_netplayer_update_packet();
	}
	
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){	
		// NETLOG
		ml_string(NOX("Server performing pre-briefing data sync"));

		if(!(Game_mode & GM_STANDALONE_SERVER)){
			multi_common_set_text(XSTR("Server performing sync\n",830),1);
		}
		
		// maybe initialize tvt and squad war stuff
		if(Netgame.type_flags & NG_TYPE_TEAM){
			multi_team_level_init();
		}	

		// force everyone into this state		
		send_netgame_update_packet();		

		if(!(Game_mode & GM_STANDALONE_SERVER)){
			multi_common_add_text(XSTR("Send update packet\n",831),1);
		}

		// setup some of my own data
		Net_player->flags |= NETINFO_FLAG_MISSION_OK;		

		// do any output stuff
		if (Game_mode & GM_STANDALONE_SERVER) {
			std_debug_set_standalone_state_string("Mission Sync");			
		}		

		// do this here to insure we have the most up to date file checksum info
		multi_get_mission_checksum(Game_current_mission_filename);
		// parse_get_file_signature(Game_current_mission_filename);
		
		if(!(Game_mode & GM_STANDALONE_SERVER)){
			multi_common_add_text(XSTR("Got file signatures\n",832),1);
		}
	} else {
		if(!(Game_mode & GM_STANDALONE_SERVER)){
			multi_common_add_text(XSTR("Sending update state packet\n",833),1);
		}
	}

	// if we're not in team vs. team mode - set all player teams to be 0, and unset all captaincy bits
	if(!(Netgame.type_flags & NG_TYPE_TEAM)){
		for(idx=0;idx<MAX_PLAYERS;idx++){
			Net_players[idx].p_info.team = 0;
			Net_players[idx].flags &= ~(NETINFO_FLAG_TEAM_CAPTAIN);
		}
	}

	// we aren't necessarily xferring the mission file yet	
	Assert(Net_player->s_info.xfer_handle == -1);

	// always call this for good measure
	multi_campaign_flush_data();

	Mission_sync_flags = 0;
	Multi_mission_loaded = 0;
}

void multi_sync_pre_do(bool API_Access)
{		
	int idx;
	
	// If I'm the server, wait for everyone to arrive in this state, then begin transferring data, etc.
	// all servers (standalone or no, go through this)
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		// wait for everyone to arrive, then request filesig from all of them
		if(multi_netplayer_state_check(NETPLAYER_STATE_MISSION_SYNC) && !(Mission_sync_flags & MS_FLAG_SENT_FILESIG) && !multi_endgame_ending()){
			send_file_sig_request(Netgame.mission_name);
			Mission_sync_flags |= MS_FLAG_SENT_FILESIG;

			if(!(Game_mode & GM_STANDALONE_SERVER)){
				multi_common_add_text(XSTR("Sent filesig request\n",834),1);
			}
		}		

		// if we're waiting for players to receive files, then check on their status
		if((Mission_sync_flags & MS_FLAG_SENT_FILESIG) && !multi_netplayer_flag_check(NETINFO_FLAG_MISSION_OK) && !multi_endgame_ending()){
			for(idx=0;idx<MAX_PLAYERS;idx++){
				// if this player is in the process of xferring a file
				if(MULTI_CONNECTED(Net_players[idx]) && (Net_players[idx].s_info.xfer_handle != -1)){
					switch(multi_xfer_get_status(Net_players[idx].s_info.xfer_handle)){
					// if it has successfully completed, set his ok flag
					case MULTI_XFER_SUCCESS :
						// set his ok flag
						Net_players[idx].flags |= NETINFO_FLAG_MISSION_OK;

						// release the xfer instance handle
						multi_xfer_release_handle(Net_players[idx].s_info.xfer_handle);
						Net_players[idx].s_info.xfer_handle = -1;
						break;
					// if it has failed or timed-out, kick the player
					case MULTI_XFER_TIMEDOUT:
					case MULTI_XFER_FAIL:
						// release the xfer handle
						multi_xfer_release_handle(Net_players[idx].s_info.xfer_handle);
						Net_players[idx].s_info.xfer_handle = -1;
						
						// kick the loser
						multi_kick_player(idx, 0, KICK_REASON_BAD_XFER);
						break;
					}
				}
			}
		}

		// NOTE : this is now obsolete
		// once everyone is verified, do any data transfer necessary
		if(multi_netplayer_flag_check(NETINFO_FLAG_MISSION_OK) && !(Mission_sync_flags & MS_FLAG_DATA_DONE) && !multi_endgame_ending()){
			// do nothing for now
			Mission_sync_flags |= MS_FLAG_DATA_DONE;						
			
			// send campaign pool data
			multi_campaign_send_pool_status();
		}

		// wait for everyone to ack on campaign pool data (even in non-campaign situations)
		if((Mission_sync_flags & MS_FLAG_DATA_DONE) && !(Mission_sync_flags & MS_FLAG_CAMP_DONE) && !multi_endgame_ending()){
			// check to see if everyone has acked the campaign pool data
			if(multi_netplayer_state_check(NETPLAYER_STATE_CPOOL_ACK)){
				Mission_sync_flags |= MS_FLAG_CAMP_DONE;
			}
		}
				
		// once everyone is verified, tell them to load the mission
		// also make sure to load the mission myself _AFTER_ telling everyone to do so. This makes the whole process
		// move along faster
		if((Mission_sync_flags & MS_FLAG_CAMP_DONE) && !(Mission_sync_flags & MS_FLAG_SENT_LOAD) && !multi_endgame_ending()){		
			send_netplayer_load_packet(NULL);			
			Mission_sync_flags |= MS_FLAG_SENT_LOAD;

			if(!(Game_mode & GM_STANDALONE_SERVER)){
				multi_common_add_text(XSTR("Sent load packet\n",835),1);
			}

			// load the mission myself, as soon as possible
			if(!Multi_mission_loaded){
				nprintf(("Network","Server loading mission...\n"));
	
				// update everyone about my status
				Net_player->state = NETPLAYER_STATE_MISSION_LOADING;
				send_netplayer_update_packet();

				game_start_mission();
				psnet_flush();
				nprintf(("Network","Done\n"));
				Multi_mission_loaded = 1;				

				// update everyone about my status
				Net_player->state = NETPLAYER_STATE_MISSION_LOADED;
				send_netplayer_update_packet();

				if(!(Game_mode & GM_STANDALONE_SERVER)){
					multi_common_add_text(XSTR("Loaded mission locally\n",836),1);
				}
			}
		}
		
		// if everyone has loaded the mission, randomly assign players to ships 
		if(multi_netplayer_state_check(NETPLAYER_STATE_MISSION_LOADED) && !(Mission_sync_flags & MS_FLAG_TS_SLOTS) && !multi_endgame_ending()){
			// call the team select function to assign players to their ships, wings, etc
			multi_ts_assign_players_all();
			send_netplayer_slot_packet();										

			// mark this flag
			Mission_sync_flags |= MS_FLAG_TS_SLOTS;
		}

		// if everyone has loaded the mission, move to the team select stage
		if(Sync_test && multi_netplayer_state_check(NETPLAYER_STATE_SLOT_ACK) && !(Mission_sync_flags & MS_FLAG_PUSHED_BRIEFING) && !multi_endgame_ending()){
			Netgame.game_state = NETGAME_STATE_BRIEFING;
			send_netgame_update_packet();   // this will push everyone into the next state

			// the standalone moves to his own wait state, whereas in the normal game mode, the server/host moves in to the
			// team select state
			if(Game_mode & GM_STANDALONE_SERVER){
				gameseq_post_event(GS_EVENT_MULTI_STD_WAIT);
			} else {
				gameseq_post_event(GS_EVENT_START_GAME);					
			}

			Mission_sync_flags |= MS_FLAG_PUSHED_BRIEFING;

			if(!(Game_mode & GM_STANDALONE_SERVER)){
				multi_common_add_text(XSTR("Moving to team select\n",837),1);
			}
		}		
	} else {
		// clients should detect here if they are doing a file xfer and do error processing
		if((Net_player->state == NETPLAYER_STATE_MISSION_XFER) && (Net_player->s_info.xfer_handle != -1) && !multi_endgame_ending()){
			switch(multi_xfer_get_status(Net_player->s_info.xfer_handle)){
			// if it has successfully completed, set his ok flag
			case MULTI_XFER_SUCCESS :	
				// release my xfer handle
				multi_xfer_release_handle(Net_player->s_info.xfer_handle);
				Net_player->s_info.xfer_handle = -1;				
				break;
				
			// if it has failed or timed-out, kick the player
			case MULTI_XFER_TIMEDOUT:
			case MULTI_XFER_FAIL:
				// release my xfer handle
				multi_xfer_release_handle(Net_player->s_info.xfer_handle);
				Net_player->s_info.xfer_handle = -1;

				// leave the game qith an error code
				multi_quit_game(PROMPT_NONE, MULTI_END_NOTIFY_NONE, MULTI_END_ERROR_XFER_FAIL);
				break;
			}
		}
	}

	// blit stuff
	if(!(Game_mode & GM_STANDALONE_SERVER) && !API_Access){
		gr_reset_clip();
		GR_MAYBE_CLEAR_RES(Multi_sync_bitmap);
		if(Multi_sync_bitmap != -1){
			gr_set_bitmap(Multi_sync_bitmap);
			gr_bitmap(0,0,GR_RESIZE_MENU);
		}
		Multi_sync_window.draw();

		multi_sync_blit_screen_all();

		gr_flip();
	}
}

void multi_sync_pre_close()
{
	// at this point, we should shut down any file xfers...
	if(Net_player->s_info.xfer_handle != -1){
		nprintf(("Network","WARNING - killing file xfer while leaving mission sync state!!!\n"));

		multi_xfer_abort(Net_player->s_info.xfer_handle);
		Net_player->s_info.xfer_handle = -1;
	}
}

void multi_sync_post_init(bool API_Access)
{   	
	multi_reset_timestamps();

	Multi_state_timestamp = UI_TIMESTAMP::immediate();

	// NETLOG
	ml_string(NOX("Performing post-briefing data sync"));
	
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		multi_common_add_text(XSTR("Server performing sync\n",830),1);
	} else {
		multi_common_add_text(XSTR("Client performing sync\n",838),1);
	}

	// everyone should re-initialize these 
	init_multiplayer_stats();

	// if I am not the master of the game, then send the firing information for my ship
	// to the host
	if ( !(Net_player->flags & NETINFO_FLAG_AM_MASTER) ){
		send_firing_info_packet();
	}	

	// if I'm not a standalone server, load up the countdown stuff
	if(!(Game_mode & GM_STANDALONE_SERVER) && !API_Access){
		generic_anim_init(&Multi_sync_countdown_anim, Multi_sync_countdown_fname[gr_screen.res]);
		Multi_sync_countdown_anim.ani.bg_type = bm_get_type(Multi_sync_bitmap);
		generic_anim_stream(&Multi_sync_countdown_anim);
		if(Multi_sync_countdown_anim.num_frames < 1){
			nprintf(("General","WARNING!, Could not load countdown animation %s!\n",Multi_sync_countdown_fname[gr_screen.res]));
		}
	}

	// create objects for all permanent observers
	multi_obs_level_init();

	// clear the game start countdown timer
	Multi_sync_countdown_timer = -1.0f;	
	Multi_sync_countdown = -1;

	// if this is a team vs. team mission, mark all ship teams appropriately
	if(Netgame.type_flags & NG_TYPE_TEAM){
		multi_team_mark_all_ships();
	}

	Mission_sync_flags = 0;
	Multi_sync_launch_pressed = 0;
}

#define MULTI_POST_TIMESTAMP			7000

extern commit_pressed_status create_wings();

void multi_sync_post_do(bool API_Access)
{	
	int idx;
	
	// only if the host is also the master should he be doing this (non-standalone situation)
	if ( Net_player->flags & NETINFO_FLAG_AM_MASTER ) {

		// once everyone gets to this screen, send them the ship classes of all ships.
		if(multi_netplayer_state_check(NETPLAYER_STATE_WAITING) && !(Mission_sync_flags & MS_FLAG_POST_DATA)) {			
			// only the host should ever do this
			if(Net_player->flags & NETINFO_FLAG_GAME_HOST){
				// at this point we want to delete all necessary ships, change all necessary ship classes, and set all weapons up
				multi_ts_create_wings();

				// update player ets settings
				for(idx=0;idx<MAX_PLAYERS;idx++){
					if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].m_player->objnum != -1)){
						multi_server_update_player_weapons(&Net_players[idx],&Ships[Objects[Net_players[idx].m_player->objnum].instance]);
					}
				}			
			}			

			// note that this is done a little differently for standalones and nonstandalones
			send_post_sync_data_packet();
			
			multi_common_add_text(XSTR("Sending post briefing block information\n",839),1);			

			Mission_sync_flags |= MS_FLAG_POST_DATA;
		}

		// send weapon slots data
		if(multi_netplayer_state_check(NETPLAYER_STATE_POST_DATA_ACK) && !(Mission_sync_flags & MS_FLAG_WSS_SLOTS)) {			
			// note that this is done a little differently for standalones and nonstandalones
			if(Netgame.type_flags & NG_TYPE_TEAM){
				send_wss_slots_data_packet(0,0);
				send_wss_slots_data_packet(1,1);
			} else {
				send_wss_slots_data_packet(0,1);
			}
			
			multi_common_add_text(XSTR("Sending weapon slots information\n",840),1);			

			Mission_sync_flags |= MS_FLAG_WSS_SLOTS;
		}
			
		// once weapon information is received, send player settings info
		if ( multi_netplayer_state_check(NETPLAYER_STATE_WSS_ACK) && !(Mission_sync_flags & MS_FLAG_PSETTINGS)) {									
			send_player_settings_packet();
			
			// server (specifically, the standalone), should set this here
			Net_player->state = NETPLAYER_STATE_SETTINGS_ACK;
			send_netplayer_update_packet();
			
			multi_common_add_text(XSTR("Sending player settings packets\n",841),1);				

			Mission_sync_flags |= MS_FLAG_PSETTINGS;			
		}					

		// check to see if the countdown timer has started and act appropriately
		if( Multi_sync_countdown_timer > -1.0f ) {

			// increment by frametime.
			Multi_sync_countdown_timer += flFrametime;

			// if the next second has expired
			if( Multi_sync_countdown_timer >= 1.0f ) {

				Multi_sync_countdown--;
				Multi_sync_countdown_timer = 0.0f;

				// if the countdown has reached 0, launch the mission
				if(Multi_sync_countdown == 0){
					Multi_sync_countdown_timer = -1.0f;

					Multi_sync_launch_pressed = 0;
					multi_sync_launch();
				}
				// otherwise send a countdown packet
				else {
					send_countdown_packet(Multi_sync_countdown);
				}
			}
		}
			
		// jump into the mission myself
		if((Multi_sync_countdown == 0) && multi_netplayer_state_check(NETPLAYER_STATE_IN_MISSION)){
			if(!((Net_player->flags & NETINFO_FLAG_GAME_HOST) && !Multi_sync_launch_pressed)){							
				Net_player->state = NETPLAYER_STATE_IN_MISSION;
				Netgame.game_state = NETGAME_STATE_IN_MISSION;				
				gameseq_post_event(GS_EVENT_ENTER_GAME);
			
				multi_common_add_text(XSTR("Moving into game\n",842),1);			
			}
		}
	}

	// host - specific stuff
	if(Net_player->flags & NETINFO_FLAG_GAME_HOST){
		// create the launch button so the host can click
		if( Sync_test && multi_netplayer_state_check(NETPLAYER_STATE_SETTINGS_ACK) ){
			multi_sync_create_launch_button();
		}
	}

	// blit stuff
	if(!(Game_mode & GM_STANDALONE_SERVER) && !API_Access){
		gr_reset_clip();	
		GR_MAYBE_CLEAR_RES(Multi_sync_bitmap);
		if(Multi_sync_bitmap != -1){
			gr_set_bitmap(Multi_sync_bitmap);
			gr_bitmap(0,0,GR_RESIZE_MENU);
		}
		Multi_sync_window.draw();

		multi_sync_blit_screen_all();

		gr_flip();
	}
}

void multi_sync_post_close(bool API_Access)
{
	int idx;

	if (!API_Access) {
		if (Multi_sync_countdown_anim.num_frames > 0)
			generic_anim_unload(&Multi_sync_countdown_anim);
	}
	// all players should reset sequencing
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(Net_player->flags & NETINFO_FLAG_CONNECTED){
			Net_players[idx].client_cinfo_seq = 0;
			Net_players[idx].client_server_seq = 0;	
		}
	}

	// multiplayer dogfight
	multi_df_level_pre_enter();				

	// clients should clear obj_pair array and add pair for themselves
	/*
	if ( MULTIPLAYER_CLIENT ) {
		obj_reset_pairs();
		obj_add_pairs( OBJ_INDEX(Player_obj) );	
	}
	*/
}

void multi_sync_display_name(const char *name,int index,int np_index)
{
	char fit[CALLSIGN_LEN+1];
	int line_height = gr_get_font_height() + 1;
	
	// make sure the string actually fits
	strcpy_s(fit,name);

	// if we're in team vs. team mode
	if(Netgame.type_flags & NG_TYPE_TEAM){
		font::force_fit_string(fit,CALLSIGN_LEN, Ms_status2_coords[gr_screen.res][MS_X_COORD] - Ms_status_coords[gr_screen.res][MS_X_COORD] - 20 - Ms_cd_icon_offset[gr_screen.res] - Ms_team_icon_offset[gr_screen.res]);			

		// if this is the currently selected player, draw him highlighted
		if(np_index == Multi_sync_player_select){
			gr_set_color_fast(&Color_text_selected);
		} else {
			gr_set_color_fast(&Color_text_normal);
		}

		// blit the string
		gr_string(Ms_status_coords[gr_screen.res][0] + Ms_cd_icon_offset[gr_screen.res] + Ms_team_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height),fit,GR_RESIZE_MENU);

		// blit his team icon 
		// team 0		
		if(Net_players[np_index].p_info.team == 0){
			// blit the team captain icon
			if(Net_players[np_index].flags & NETINFO_FLAG_TEAM_CAPTAIN){				
				if(Multi_common_icons[MICON_TEAM0_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0_SELECT]);
					gr_bitmap(Ms_status_coords[gr_screen.res][MS_X_COORD] + Ms_cd_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height) - 2, GR_RESIZE_MENU);
				} 
			}
			// normal team member icon
			else {
				if(Multi_common_icons[MICON_TEAM0] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM0]);
					gr_bitmap(Ms_status_coords[gr_screen.res][MS_X_COORD] + Ms_cd_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height) - 2, GR_RESIZE_MENU);
				}
			}
		}
		// team 1
		else if(Net_players[np_index].p_info.team == 1){			
			// blit the team captain icon
			if(Net_players[np_index].flags & NETINFO_FLAG_TEAM_CAPTAIN){
				if(Multi_common_icons[MICON_TEAM1_SELECT] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1_SELECT]);
					gr_bitmap(Ms_status_coords[gr_screen.res][MS_X_COORD] + Ms_cd_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height) - 2, GR_RESIZE_MENU);
				}
			}
			// normal team member icon
			else {
				if(Multi_common_icons[MICON_TEAM1] != -1){
					gr_set_bitmap(Multi_common_icons[MICON_TEAM1]);
					gr_bitmap(Ms_status_coords[gr_screen.res][MS_X_COORD] + Ms_cd_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height) - 2, GR_RESIZE_MENU);
				}
			}
		}		
	} else {
		font::force_fit_string(fit, CALLSIGN_LEN, Ms_status2_coords[gr_screen.res][MS_X_COORD] - Ms_status_coords[gr_screen.res][MS_X_COORD] - 20 - Ms_cd_icon_offset[gr_screen.res]);

		// if this is the currently selected player, draw him highlighted
		if(np_index == Multi_sync_player_select){
			gr_set_color_fast(&Color_text_selected);
		} else {
			gr_set_color_fast(&Color_text_normal);
		}

		// blit the string
		gr_string(Ms_status_coords[gr_screen.res][MS_X_COORD] + Ms_cd_icon_offset[gr_screen.res], Ms_status_coords[gr_screen.res][MS_Y_COORD] + (index * line_height),fit,GR_RESIZE_MENU);
	}
}

void multi_sync_display_status(const char *status,int index)
{
	char fit[250];

	// make sure the string actually fits
	strcpy_s(fit, status);
	font::force_fit_string(fit, 249, Ms_status2_coords[gr_screen.res][MS_W_COORD] - 20);
	gr_set_color_fast(&Color_bright);	
	gr_string(Ms_status2_coords[gr_screen.res][MS_X_COORD], Ms_status2_coords[gr_screen.res][MS_Y_COORD] + (index * (gr_get_font_height() + 1)), fit, GR_RESIZE_MENU);		
}

void multi_sync_force_start_pre()
{
	int idx;
	int want_state = NETPLAYER_STATE_SLOT_ACK;	// kick any players who are still in this state

	// go through the player list and boot anyone who isn't in the right state
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_player != &Net_players[idx]) && (Net_players[idx].state == want_state)){		
			multi_kick_player(idx,0);				
		}
	}
}

void multi_sync_force_start_post()
{
	int idx,idx2;
	int kill_state[3];	
	int num_kill_states;
	
	// determine the state we want all players in so that we can find those who are not in the state	
	kill_state[0] = NETPLAYER_STATE_BRIEFING;
	kill_state[1] = NETPLAYER_STATE_SHIP_SELECT;
	kill_state[2] = NETPLAYER_STATE_WEAPON_SELECT;
	num_kill_states = 3;	

	// go through the player list and boot anyone who isn't in the right state
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_player != &Net_players[idx])){
			// check against all kill state
			for(idx2 = 0;idx2<num_kill_states;idx2++){
				if(Net_players[idx].state == kill_state[idx2]){
					multi_kick_player(idx,0);
					break;
				}
			}
		}
	}
}

void multi_sync_start_countdown()
{
	// don't allow repeat button presses
	if(Multi_sync_launch_pressed){
		return;
	}
	
	Multi_sync_launch_pressed = 1;

	// if I'm the server, begin the countdown
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);
		Multi_sync_countdown_timer = 0.0f;
		Multi_sync_countdown = MULTI_SYNC_COUNTDOWN_TIME;

		// send an initial countdown value
		send_countdown_packet(Multi_sync_countdown);
	}
	// otherwise send the "start countdown" packet to the standalone
	else {
		Assert(Net_player->flags & NETINFO_FLAG_GAME_HOST);
		send_countdown_packet(-1);
	}
}

void multi_sync_launch()
{	
	// don't allow repeat button presses
	if(Multi_sync_launch_pressed){
		return;
	}

	Multi_sync_launch_pressed = 1;

	// NETLOG
	ml_printf(NOX("Entering mission %s"), Game_current_mission_filename);

	// tell everyone to jump into the mission
	send_jump_into_mission_packet();
	Multi_state_timestamp = ui_timestamp(MULTI_POST_TIMESTAMP);

	// set the # of players at the start of the mission
	Multi_num_players_at_start = multi_num_players();
	nprintf(("Network","# of players at start of mission : %d\n", Multi_num_players_at_start));
	
	// initialize datarate limiting for all clients
	multi_oo_rate_init_all();	
				
	multi_common_add_text(XSTR("Sending mission start packet\n",843),1);				
}

void multi_sync_create_launch_button()
{
	if (!Multi_launch_button_created) {		
		// create the object
		Multi_sync_buttons[gr_screen.res][MS_LAUNCH].button.create(&Multi_sync_window, "", Multi_sync_buttons[gr_screen.res][MS_LAUNCH].x, Multi_sync_buttons[gr_screen.res][MS_LAUNCH].y, 1, 1, 0, 1);

		// set the sound to play when highlighted
		Multi_sync_buttons[gr_screen.res][MS_LAUNCH].button.set_highlight_action(common_play_highlight_sound);

		// set the ani for the button
		Multi_sync_buttons[gr_screen.res][MS_LAUNCH].button.set_bmaps(Multi_sync_buttons[gr_screen.res][MS_LAUNCH].filename, 3, 0);

		// set the hotspot
		Multi_sync_buttons[gr_screen.res][MS_LAUNCH].button.link_hotspot(Multi_sync_buttons[gr_screen.res][MS_LAUNCH].hotspot);

		// hotkey
		Multi_sync_buttons[gr_screen.res][MS_LAUNCH].button.set_hotkey(KEY_CTRLED+KEY_ENTER);

		// create the text for the button
		Multi_sync_window.add_XSTR(&Multi_sync_text[gr_screen.res][MST_LAUNCH]);

		// increment the button count so we start checking this one
		Multi_sync_button_count++;

		Multi_launch_button_created = 1;
	}
}

void multi_sync_handle_plist()
{
	int idx;
	int my;
	int select_index;
	
	// if we don't have a currently selected player, select one
	if((Multi_sync_player_select < 0) || !MULTI_CONNECTED(Net_players[Multi_sync_player_select])){
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
				Multi_sync_player_select = idx;
				break;
			}
		}
	}
	
	// check for button list presses
	if(Multi_sync_plist_button.pressed()){
		// get the y mouse coords
		Multi_sync_plist_button.get_mouse_pos(NULL,&my);

		// get the index of the item selected
		select_index = my / (gr_get_font_height() + 1);

		// if the index is greater than the current # connections, do nothing
		if(select_index > (multi_num_connections() - 1)){
			return;
		}

		// translate into an absolute Net_players[] index (get the Nth net player)
		Multi_sync_player_select = -1;
		for(idx=0;idx<MAX_PLAYERS;idx++){
			if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
				select_index--;
			}

			// if we've found the item we're looking for
			if(select_index < 0){
				Multi_sync_player_select = idx;
				break;
			}
		}

		// if for some bizarre reason, this is an invalid player, unselect him and wait for the next interation
		// of the loop
		if((Multi_sync_player_select >= 0) && (!MULTI_CONNECTED(Net_players[Multi_sync_player_select]) || MULTI_STANDALONE(Net_players[Multi_sync_player_select])) ){
			Multi_sync_player_select = -1;
		}
	}
}


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER DEBRIEF SCREEN 
//

// other relevant data
int Multi_debrief_accept_hit;
int Multi_debrief_replay_hit;

// set if the server has left the game
int Multi_debrief_server_left = 0;

// if we've reported on TvT status all players are in the debrief
int Multi_debrief_reported_tvt = 0;

// whether stats are being accepted
// -1 == no decision yet
// 1 == accepted
// 0 == tossed

// kazan - for internal purposes stats are always accepted by default
int Multi_debrief_stats_accept_code = 1;

int Multi_debrief_server_framecount = 0;

float Multi_debrief_time = 0.0f;
float Multi_debrief_resend_time = 10.0f;

void multi_debrief_init()
{			
	int idx;

	Multi_debrief_time = 0.0f;
	Multi_debrief_resend_time = 10.0f;
	Multi_already_tried_stats_submit = false;
	
	// do this to notify the standalone or the normal server that we're in the debrief state and ready to receive packets
	if (!(Net_player->flags & NETINFO_FLAG_AM_MASTER)) {
		Net_player->state = NETPLAYER_STATE_DEBRIEF;
		send_netplayer_update_packet();
	}	

	// unflag some stuff
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(MULTI_CONNECTED(Net_players[idx])){
			Net_players[idx].flags &= ~(NETINFO_FLAG_RESPAWNING | NETINFO_FLAG_LIMBO | NETINFO_FLAG_WARPING_OUT);
		}
	}
	
	// if text input mode is active, clear it
	multi_msg_text_flush();	
	
	// the server has not left yet
	Multi_debrief_server_left = 0;

	// have not hit accept or replay yet
	Multi_debrief_accept_hit = 0;
	Multi_debrief_replay_hit = 0;

	// stats have not been accepted yet
	Multi_debrief_stats_accept_code = -1;

	// mark stats as not being store yet
	Netgame.flags &= ~(NG_FLAG_STORED_MT_STATS);

	// no report on TvT yet
	Multi_debrief_reported_tvt = 0;

	Multi_debrief_server_framecount = 0;
}

void multi_debrief_do_frame()
{
	Multi_debrief_time += flFrametime;

	// set the netgame state to be debriefing when appropriate
	if((Net_player->flags & NETINFO_FLAG_AM_MASTER) && (Netgame.game_state != NETGAME_STATE_DEBRIEF) && multi_netplayer_state_check3(NETPLAYER_STATE_DEBRIEF, NETPLAYER_STATE_DEBRIEF_ACCEPT, NETPLAYER_STATE_DEBRIEF_REPLAY)){
		Netgame.game_state = NETGAME_STATE_DEBRIEF;
		send_netgame_update_packet();
	}
	
	// evaluate all server stuff
	if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
		multi_debrief_server_process();
	}			
}

void multi_debrief_close()
{	
	if ( MULTIPLAYER_CLIENT && (Netgame.game_state == NETGAME_STATE_MISSION_SYNC) ){
		gamesnd_play_iface( InterfaceSounds::COMMIT_PRESSED );
	}
}

// handle optional mission loop
void multi_maybe_set_mission_loop()
{
	int cur = Campaign.current_mission;
	if (Campaign.missions[cur].flags & CMISSION_FLAG_HAS_LOOP) {
		Assert(Campaign.loop_mission != CAMPAIGN_LOOP_MISSION_UNINITIALIZED);
	}
	bool require_repeat_mission = (Campaign.current_mission == Campaign.next_mission);

	// check for (1) mission loop available, (2) don't have to repeat last mission
	if ( (Campaign.missions[cur].flags & CMISSION_FLAG_HAS_LOOP) && (Campaign.loop_mission != -1) && !require_repeat_mission ) {

		char buffer[512];
		debrief_assemble_optional_mission_popup_text(buffer, Campaign.missions[cur].mission_branch_desc);

		int choice = popup(0 , 2, POPUP_NO, POPUP_YES, buffer);
		if (choice == 1) {
			Campaign.loop_enabled = 1;
			Campaign.next_mission = Campaign.loop_mission;
		}
	}
}

// handle all cases for when the accept key is hit in a multiplayer debriefing
void multi_debrief_accept_hit()
{
	// if we already accepted, do nothing
	// but he may need to hit accept again after the server has left the game, so allow this
	if(Multi_debrief_accept_hit){
		return;
	}
	
	// mark this so that we don't hit it again
	Multi_debrief_accept_hit = 1;

	gamesnd_play_iface(InterfaceSounds::COMMIT_PRESSED);

	// if the server has left the game, always just end the game. 
	if(Multi_debrief_server_left){
		if(!multi_quit_game(PROMPT_ALL)){
			Multi_debrief_server_left = 1;
			Multi_debrief_accept_hit = 0;
		} else {
			Multi_debrief_server_left = 0;
		}			
	} else {		
		// query the host and see if he wants to accept stats
		if(Net_player->flags & NETINFO_FLAG_GAME_HOST){
			// if we're on a tracker game, he gets no choice for storing stats
			if (MULTI_IS_TRACKER_GAME) {
				// if not on standalone, send stats
				if (Net_player->flags & NETINFO_FLAG_AM_MASTER) {
					if (!(Multi_already_tried_stats_submit)) {
						int stats_saved = multi_fs_tracker_store_stats();
						Multi_already_tried_stats_submit = true;

						if (stats_saved) {
							Netgame.flags |= NG_FLAG_STORED_MT_STATS;
							send_netgame_update_packet();
						} else {
							send_store_stats_packet(0);
						}

						if (Netgame.type_flags & NG_TYPE_SW) {
							multi_sw_report(stats_saved);
						}
					}
				}

				multi_maybe_set_mission_loop();
			} else {
				int res = popup(PF_TITLE | PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON | PF_IGNORE_ESC,3,XSTR("&Cancel",779),XSTR("&Accept",844),XSTR("&Toss",845),XSTR("(Continue Netgame)\nDo you wish to accept these stats?",846));
		
				// evaluate the result
				switch(res){
				// undo the accept
				case -1:
				case 0:
					Multi_debrief_accept_hit = 0;
					return;

				// set the accept code to be "not accepting"
				case 2 :
					multi_debrief_stats_toss();
					multi_maybe_set_mission_loop();
					break;
				
				// accept the stats and continue
				case 1 :
					multi_debrief_stats_accept();
					multi_maybe_set_mission_loop();
					break;
				}
			}
		}

		// set my netplayer state to be "debrief_accept", and be done with it
		Net_player->state = NETPLAYER_STATE_DEBRIEF_ACCEPT;
		send_netplayer_update_packet();
	}
}

// handle all cases for when the escape key is hit in a multiplayer debriefing
void multi_debrief_esc_hit()
{
	int res;

	// if the server has left
	if(Multi_debrief_server_left){
		multi_quit_game(PROMPT_ALL);
		return;
	}
	
	// display a popup
	if(Net_player->flags & NETINFO_FLAG_GAME_HOST){		
		// if the stats have already been accepted
		if((Multi_debrief_stats_accept_code != -1) || (MULTI_IS_TRACKER_GAME)){
			// if not on standalone, maybe send stats
			if ( (Net_player->flags & NETINFO_FLAG_AM_MASTER) && MULTI_IS_TRACKER_GAME ) {
				if (!(Multi_already_tried_stats_submit) ) {
					int stats_saved = multi_fs_tracker_store_stats();
					Multi_already_tried_stats_submit = true;

					if (stats_saved) {
						Netgame.flags |= NG_FLAG_STORED_MT_STATS;
						send_netgame_update_packet();
					} else {
						send_store_stats_packet(0);
					}

					if (Netgame.type_flags & NG_TYPE_SW) {
						multi_sw_report(stats_saved);
					}
				}

			}

			multi_quit_game(PROMPT_HOST);
		} else {
			res = popup(PF_TITLE | PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON | PF_IGNORE_ESC,3,XSTR("&Cancel",779),XSTR("&Accept",844),XSTR("&Toss",845),XSTR("(Exit Netgame)\nDo you wish to accept these stats?",847));
		
			// evaluate the result
			switch(res){			
			// undo the accept
			case -1:
			case 0:				
				break;

			// set the accept code to be "not accepting"
			case 2 :
				multi_debrief_stats_toss();
				multi_quit_game(PROMPT_NONE);
				break;
				
			// accept the stats and continue
			case 1 :
				multi_debrief_stats_accept();
				multi_quit_game(PROMPT_NONE);
				break;						
			}		
		}
	} else {		
		// if the stats haven't been accepted yet, or this is a tracker game
		if((Multi_debrief_stats_accept_code == -1) && !(MULTI_IS_TRACKER_GAME)){
			res = popup(PF_BODY_BIG | PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON,2,XSTR("&Cancel",779),XSTR("&Leave",848),XSTR("Are you sure you want to leave the netgame before stats are stored?",849));

			// evaluate the result
			if(res == 1){
				multi_quit_game(PROMPT_NONE);
			}
		}
		// otherwise go through the normal endgame channels
		else {
			multi_quit_game(PROMPT_ALL);
		}		
	}
}

void multi_debrief_replay_hit()
{
	// only the host should ever get here
	Assert(Net_player->flags & NETINFO_FLAG_GAME_HOST);

	// if the button was already pressed, do nothing
	if(Multi_debrief_accept_hit){
		return;
	}
	
	// same as hittin the except button except no stats are kept
	Multi_debrief_accept_hit = 1;

	// mark myself as being in the replay state so we know what to do next
	Net_player->state = NETPLAYER_STATE_DEBRIEF_REPLAY;
	send_netplayer_update_packet();
}

// call this when the server has left and we would otherwise be saying "contact lost with server
void multi_debrief_server_left()
{
	// the server left
	Multi_debrief_server_left = 1;

	// undo any "accept" hit so that clients can hit accept again to leave
	Multi_debrief_accept_hit = 0;
}

void multi_debrief_stats_accept()
{
	// don't do anything if we've already accepted
	if(Multi_debrief_stats_accept_code != -1){
		return;
	}
	
	Multi_debrief_stats_accept_code = 1;

	// if we're the host, and we're on a standalone, tell the standalone to begin the stats storing process
	if((Net_player->flags & NETINFO_FLAG_GAME_HOST) || (Net_player->flags & NETINFO_FLAG_AM_MASTER)){
		// send a packet to the players telling them to store their stats
		send_store_stats_packet(1);
	} 

	// add a chat line saying "stats have been accepted"
	multi_display_chat_msg(XSTR("<stats have been accepted>",850),0,0);

	// NETLOG
	ml_string(NOX("Stats stored"));
}

void multi_debrief_stats_toss()
{
	// don't do anything if we've already accepted
	if(Multi_debrief_stats_accept_code != -1){
		return;
	}
	
	Multi_debrief_stats_accept_code = 0;

	// if we're the host, and we're on a standalone, tell everyone to "toss" stats
	// Kazan - or how about we don't - we tell them we stored them
	if((Net_player->flags & NETINFO_FLAG_GAME_HOST) || (Net_player->flags & NETINFO_FLAG_AM_MASTER)){
		// send a packet to the players telling them to store their stats
		send_store_stats_packet(1);
	} 

	// add a chat line saying "stats have been accepted"
	//multi_display_chat_msg(XSTR("<stats have been tossed>",851),0,0);

	// NETLOG
	ml_string(NOX("Stats tossed"));
}

int multi_debrief_stats_accept_code()
{
	return Multi_debrief_stats_accept_code;
}

void multi_debrief_server_process()
{	
	int idx;
	int player_status,other_status;

	Multi_debrief_server_framecount++;

	// if we're > 10 seconds into the debrief and not everyone is here, try warping everyone out again
	if((Multi_debrief_time >= Multi_debrief_resend_time) && !multi_netplayer_state_check3(NETPLAYER_STATE_DEBRIEF, NETPLAYER_STATE_DEBRIEF_ACCEPT, NETPLAYER_STATE_DEBRIEF_REPLAY, 1)){
		// find all players who are not in the debrief state and hit them with the endgame packet
		for(idx=0; idx<MAX_PLAYERS; idx++){
			if( MULTI_CONNECTED(Net_players[idx]) && (Net_player != &Net_players[idx]) && 
				( ( Net_players[idx].state != NETPLAYER_STATE_DEBRIEF ) && 
				  ( Net_players[idx].state != NETPLAYER_STATE_DEBRIEF_ACCEPT ) && 
				  ( Net_players[idx].state != NETPLAYER_STATE_DEBRIEF_REPLAY ) ) ){
				send_endgame_packet(&Net_players[idx]);
			}
		}

		// next check time
		Multi_debrief_resend_time += 7.0f;
	}

	// evaluate the status of all players in the game (0 == not ready, 1 == ready to continue, 2 == ready to replay)
	other_status = 1;

	// check all players
	for(idx=0;idx<MAX_PLAYERS;idx++){
		if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_HOST(Net_players[idx])){					
			if(Net_players[idx].state != NETPLAYER_STATE_DEBRIEF_ACCEPT){
				other_status = 0;
				break;
			}
		}
	}

	// if we haven't already reported TvT results
	if(multi_netplayer_state_check3(NETPLAYER_STATE_DEBRIEF, NETPLAYER_STATE_DEBRIEF_ACCEPT, NETPLAYER_STATE_DEBRIEF_REPLAY) && (Netgame.type_flags & NG_TYPE_TEAM) && !Multi_debrief_reported_tvt && (Multi_debrief_server_framecount > 4)){
		multi_team_report();
		Multi_debrief_reported_tvt = 1;
	}	

	// if all other players are good to go, check the host
	if(other_status){
		// if he is ready to continue
		if(Netgame.host->state == NETPLAYER_STATE_DEBRIEF_ACCEPT){					
			player_status = 1;			
		} 
		// if he wants to replay the mission
		else if(Netgame.host->state == NETPLAYER_STATE_DEBRIEF_REPLAY){
			player_status = 2;			
		} 
		// if he is not ready
		else {
			player_status = 0;
		}
	}
	// if all players are _not_ good to go
	else {
		player_status = 0;
	}
		
	// if we're in the debriefing state in a campaign mode, process accordingly
	if(Netgame.campaign_mode == MP_CAMPAIGN){
		multi_campaign_do_debrief(player_status);
	}
	// otherwise process as normal (looking for all players to be ready to go to the next mission
	else {
		if(player_status == 1){
			multi_flush_mission_stuff();

			// set the netgame state to be forming and continue
			Netgame.game_state = NETGAME_STATE_FORMING;
			send_netgame_update_packet();

			// move to the proper state
			if(Game_mode & GM_STANDALONE_SERVER){
				gameseq_post_event(GS_EVENT_STANDALONE_MAIN);
			} else {
				gameseq_post_event(GS_EVENT_MULTI_HOST_SETUP);
			}

			multi_reset_timestamps();
		} else if(player_status == 2){
			multi_flush_mission_stuff();

			// tell everyone to move into the pre-briefing sync state
			Netgame.game_state = NETGAME_STATE_MISSION_SYNC;
			send_netgame_update_packet();

			// move back to the mission sync screen for the same mission again
			Multi_sync_mode = MULTI_SYNC_PRE_BRIEFING;
			gameseq_post_event(GS_EVENT_MULTI_MISSION_SYNC);

			multi_reset_timestamps();
		}
	}	
}


// -------------------------------------------------------------------------------------------------------------
// 
// MULTIPLAYER PASSWORD POPUP
//

//XSTR:OFF
// bitmaps defs
static const char *Multi_pwd_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"Password",			// GR_640
	"2_Password"		// GR_1024
};

static const char *Multi_pwd_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"Password-M",		// GR_640
	"2_Password-M"		// GR_1024
};

//XSTR:ON

// constants for coordinate lookup
#define MPWD_X_COORD 0
#define MPWD_Y_COORD 1
#define MPWD_W_COORD 2
#define MPWD_H_COORD 3

// button defs
#define MULTI_PWD_NUM_BUTTONS			2
#define MPWD_CANCEL			0
#define MPWD_COMMIT			1

// password area defs
int Mpwd_coords[GR_NUM_RESOLUTIONS][4] = {
	{ // GR_640
		134, 112, 367, 15
	},
	{ // GR_1024
		215, 190, 587, 24
	}
};

UI_WINDOW Multi_pwd_window;												// the window object for the join screen
UI_INPUTBOX	Multi_pwd_passwd;												// for Netgame.passwd
int Multi_pwd_bitmap;														// the background bitmap
int Multi_passwd_background = -1;
int Multi_passwd_done = -1;
int Multi_passwd_running = 0;

// password buttons
ui_button_info Multi_pwd_buttons[GR_NUM_RESOLUTIONS][MULTI_PWD_NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info("PWB_00",	411,	151,	405,	141,	0),
		ui_button_info("PWB_01",	460,	151,	465,	141,	1),
	}, 
	{ // GR_1024
		ui_button_info("2_PWB_00",	659,	242,	649,	225,	0),
		ui_button_info("2_PWB_01",	737,	242,	736,	225,	1),
	}, 
};

// text
#define MULTI_PWD_NUM_TEXT				3
UI_XSTR Multi_pwd_text[GR_NUM_RESOLUTIONS][MULTI_PWD_NUM_TEXT] = {
	{ // GR_640
		{ "Cancel",			387,	400,	141,	UI_XSTR_COLOR_GREEN, -1,	&Multi_pwd_buttons[0][MPWD_CANCEL].button},
		{ "Commit",			1062,	455,	141,	UI_XSTR_COLOR_GREEN, -1,	&Multi_pwd_buttons[0][MPWD_COMMIT].button},
		{ "Enter Password",	1332,	149,	92,	UI_XSTR_COLOR_GREEN, -1,	NULL},
	},
	{ // GR_1024
		{ "Cancel",			387,	649,	225,	UI_XSTR_COLOR_GREEN, -1,	&Multi_pwd_buttons[1][MPWD_CANCEL].button},
		{ "Commit",			1062,	736,	225,	UI_XSTR_COLOR_GREEN, -1,	&Multi_pwd_buttons[1][MPWD_COMMIT].button},
		{ "Enter Password",	1332,	239,	148,	UI_XSTR_COLOR_GREEN, -1,	NULL},
	}
};

// initialize all graphics, etc
void multi_passwd_init()
{
	int idx;

	// store the background as it currently is
	Multi_passwd_background = gr_save_screen();	
	
	// create the interface window
	Multi_pwd_window.create(0,0,gr_screen.max_w_unscaled,gr_screen.max_h_unscaled,0);
	Multi_pwd_window.set_mask_bmap(Multi_pwd_bitmap_mask_fname[gr_screen.res]);

	// load the background bitmap
	Multi_pwd_bitmap = bm_load(Multi_pwd_bitmap_fname[gr_screen.res]);
	if(Multi_pwd_bitmap < 0){
		// we failed to load the bitmap - this is very bad
		Int3();
	}
			
	// create the interface buttons
	for(idx=0; idx<MULTI_PWD_NUM_BUTTONS; idx++){
		// create the object
		Multi_pwd_buttons[gr_screen.res][idx].button.create(&Multi_pwd_window, "", Multi_pwd_buttons[gr_screen.res][idx].x, Multi_pwd_buttons[gr_screen.res][idx].y, 1, 1, 0, 1);

		// set the sound to play when highlighted
		Multi_pwd_buttons[gr_screen.res][idx].button.set_highlight_action(common_play_highlight_sound);

		// set the ani for the button
		Multi_pwd_buttons[gr_screen.res][idx].button.set_bmaps(Multi_pwd_buttons[gr_screen.res][idx].filename);

		// set the hotspot
		Multi_pwd_buttons[gr_screen.res][idx].button.link_hotspot(Multi_pwd_buttons[gr_screen.res][idx].hotspot);
	}	

	// add all xstrs
	for(idx=0; idx<MULTI_PWD_NUM_TEXT; idx++){
		Multi_pwd_window.add_XSTR(&Multi_pwd_text[gr_screen.res][idx]);
	}
	
	// create the password input box
	Multi_pwd_passwd.create(&Multi_pwd_window, Mpwd_coords[gr_screen.res][MPWD_X_COORD], Mpwd_coords[gr_screen.res][MPWD_Y_COORD],Mpwd_coords[gr_screen.res][MPWD_W_COORD], MAX_PASSWD_LEN, "", UI_INPUTBOX_FLAG_ESC_CLR | UI_INPUTBOX_FLAG_INVIS, -1, &Color_normal);
	Multi_pwd_passwd.set_focus();
	
	// link the enter key to ACCEPT
	Multi_pwd_buttons[gr_screen.res][MPWD_COMMIT].button.set_hotkey(KEY_ENTER);

	Multi_passwd_done = -1;
	Multi_passwd_running = 1;
}

// close down all graphics, etc
void multi_passwd_close()
{
	// unload any bitmaps
	bm_release(Multi_pwd_bitmap);		
		
	// destroy the UI_WINDOW
	Multi_pwd_window.destroy();

	// free up the saved background screen
	if(Multi_passwd_background >= 0){
		gr_free_screen(Multi_passwd_background);	
		Multi_passwd_background = -1;
	}

	Multi_passwd_running = 0;
}

// process any button pressed
void multi_passwd_process_buttons()
{
	// if the accept button was pressed
	if(Multi_pwd_buttons[gr_screen.res][MPWD_COMMIT].button.pressed()){
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		Multi_passwd_done = 1;
	}

	// if the cancel button was pressed
	if(Multi_pwd_buttons[gr_screen.res][MPWD_CANCEL].button.pressed()){
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
		Multi_passwd_done = 0;
	}
}

// run the passwd popup
void multi_passwd_do(char *passwd)
{
	int k;

	while(Multi_passwd_done == -1){	
		// set frametime and run background stuff
		game_set_frametime(-1);
		game_do_state_common(gameseq_get_state());

		k = Multi_pwd_window.process();

		// process any keypresses
		switch(k){
		case KEY_ESC :							
			// set this to indicate the user has cancelled for one reason or another
			Multi_passwd_done = 0;
			break;		
		}	

		// if the input box text has changed
		if(Multi_pwd_passwd.changed()){
			strcpy(passwd,"");
			Multi_pwd_passwd.get_text(passwd, MAX_PASSWD_LEN+1);
		}

		// process any button pressed
		multi_passwd_process_buttons();
	
		// draw the background, etc
		gr_reset_clip();
		gr_clear();
		if(Multi_passwd_background >= 0){
			gr_restore_screen(Multi_passwd_background);		
		}
		gr_set_bitmap(Multi_pwd_bitmap);
		gr_bitmap(0,0,GR_RESIZE_MENU);
		Multi_pwd_window.draw();
			
		// flip the buffer
		gr_flip();
	}
}

// bring up the password string popup, fill in passwd (return 1 if accept was pressed, 0 if cancel was pressed)
int multi_passwd_popup(char *passwd)
{
	// if the popup is already running for some reason, don't do anything
	if(Multi_passwd_running){
		return 0;
	}

	// initialize all graphics
	multi_passwd_init();

	// run the popup
	multi_passwd_do(passwd);

	// shut everything down
	multi_passwd_close();

	return Multi_passwd_done;
}