UTGame.UTUIFrontEnd_Multiplayer

/**
 * Copyright 1998-2008 Epic Games, Inc. All Rights Reserved.
 *
 * Multiplayer Scene for UT3.
 */

class UTUIFrontEnd_Multiplayer extends UTUIFrontEnd_BasicMenu
	dependson(UTCustomChar_Data)
	dependson(UTUIScene_MessageBox);

const MULTIPLAYER_OPTION_QUICKMATCH = 0;
const MULTIPLAYER_OPTION_JOINGAME = 1;
const MULTIPLAYER_OPTION_JOINGAMELAN = 2;
const MULTIPLAYER_OPTION_HOSTGAME = 3;

/** Reference to the quick match scene. */
var string	QuickMatchScene;

/** Reference to the host game scene. */
var string	HostScene;

/** Reference to the join game scene. */
var string	JoinScene;

/** Reference to the character selection scene. */
var string	CharacterSelectionScene;

/** Reference to the settings panels scene. */
var string	SettingsPanelsScene;

/** indicates that the player's profile should be saved */
var	transient	bool	bProfileNeedsSaving;

/** Whether or not we have already displayed the new player message box to the user. */
var transient	bool bDisplayedNewPlayerMessageBox;

/** @return bool Returns whether or not this user has saved character data. */
function bool HasSavedCharacterData()
{
	local bool bHaveLoadedCharData;
	local string CharacterDataStr;

	bHaveLoadedCharData = false;


	if( GetDataStoreStringValue("<OnlinePlayerData:ProfileData.CustomCharData>", CharacterDataStr, Self, GetPlayerOwner())
	&&	Len(CharacterDataStr) > 0 )
	{
		bHaveLoadedCharData = true;
	}

	return bHaveLoadedCharData;
}

/** Called when the screen has finished showing. */
function OnMainRegion_Show_UIAnimEnd(UIObject AnimTarget, int AnimIndex, UIAnimationSeq AnimSeq)
{
	Super.OnMainRegion_Show_UIAnimEnd(AnimTarget, AnimIndex, AnimSeq);

	if ( AnimTarget.AnimStack[AnimIndex].SeqRef.SeqName == 'SceneShowInitial' )
	{
		if ( CheckLoginAndError(GetPlayerControllerId(GetPlayerIndex()), true, ,"<Strings:UTGameUI.Errors.OnlineRequiredForInternet_Message>") )
		{
			PerformMultiplayerChecks();
		}
		else
		{
			GetSceneClient().bKillRestoreMenuProgression = true;
		}
	}
}

/**
 * Checks various conditions required to play online and displays the relevant messages to the user if any online features
 * will be disabled.
 */
function PerformMultiplayerChecks()
{
	local UTProfileSettings Profile;
	local UTUIScene_MessageBox MessageBoxReference;
	local int CurrentValue, ControllerId;
	local string ChatRestrictionValue;
	local OnlinePlayerInterface PlayerInt;

	Profile = GetPlayerProfile();
	if ( Profile != None )
	{
		if(!IsConsole()
		&&(!Profile.GetProfileSettingValueInt(class'UTProfileSettings'.const.UTPID_FirstTimeMultiplayer, CurrentValue) || CurrentValue!=1) )
		{
			CurrentValue = 1;
			Profile.SetProfileSettingValueInt(class'UTProfileSettings'.const.UTPID_FirstTimeMultiplayer, CurrentValue);
			MarkProfileDirty(true);

			MessageBoxReference = GetMessageBoxScene();
			MessageBoxReference.DisplayAcceptBox("<Strings:UTGameUI.MessageBox.FirstTimeMultiplayer_Message>",
				"<Strings:UTGameUI.MessageBox.FirstTimeMultiplayer_Title>", OnFirstTimeMultiplayer_Confirm);
		}
		else
		{
			if (!GetDataStoreStringValue("<Registry:PerformedChatRestrictionCheck>", ChatRestrictionValue, Self, GetPlayerOwner())
			||	ChatRestrictionValue != "1")
			{
				ChatRestrictionValue = "1";
				SetDataStoreStringValue("<Registry:PerformedChatRestrictionCheck>", ChatRestrictionValue, Self, GetPlayerOwner());

				ControllerId = GetPlayerOwner().ControllerId;
				PlayerInt = GetPlayerInterface();
				if ( IsLoggedIn(ControllerId, true) && PlayerInt != None && PlayerInt.CanCommunicate(ControllerId) == FPL_Disabled )
				{
					GetMessageBoxScene().DisplayAcceptBox("<Strings:UTGameUI.Errors.CommunicationRequired_Message>", "<Strings:UTGameUI.Errors.CommunicationRequired_Title>",
						OnChatRestrictionConfirm);
				}
				else
				{
					OnChatRestrictionConfirm(None, 0, GetPlayerIndex());
				}
			}
			// See if the current player hasn't setup a character yet.
			else if ( !bDisplayedNewPlayerMessageBox )
			{
				bDisplayedNewPlayerMessageBox=true;
				DisplayNewPlayerMessageBox();
			}
		}
	}
}

/** Callback for when the login changes after showing the login UI. */
function OnLoginUI_LoginChange()
{
	Super.OnLoginUI_LoginChange();

	PerformMultiplayerChecks();
}

/**
 * Delegate used in notifying the UI/game that the manual login failed after showing the login UI.
 *
 * @param LocalUserNum the controller number of the associated user
 * @param ErrorCode the async error code that occurred
 */
function OnLoginUI_LoginFailed(byte LocalUserNum,EOnlineServerConnectionStatus ErrorCode)
{
	Super.OnLoginUI_LoginFailed(LocalUserNum, ErrorCode);

	PerformMultiplayerChecks();
}

/**
 * Called when the user dismisses the "you can't chat online" message box
 */
function OnChatRestrictionConfirm(UTUIScene_MessageBox MessageBox, int SelectedOption, int PlayerIndex)
{
	if(bDisplayedNewPlayerMessageBox==false)
	{
		bDisplayedNewPlayerMessageBox=true;
		DisplayNewPlayerMessageBox();
	}
}

/**
 * Callback when the user dismisses the firsttime multiplayer message box.
 */
function OnFirstTimeMultiplayer_Confirm(UTUIScene_MessageBox MessageBox, int SelectedOption, int PlayerIndex)
{
	OpenSceneByName(SettingsPanelsScene, false, OnSettingsSceneOpened);
}

/** Callback for when the settings scene has opened. */
function OnSettingsSceneOpened(UIScene OpenedScene, bool bInitialActivation)
{
	local UTUIFrontEnd_SettingsPanels PanelSceneInst;

	PanelSceneInst = UTUIFrontEnd_SettingsPanels(OpenedScene);

	PanelSceneInst.OnMarkProfileDirty = MarkProfileDirty;
	PanelSceneInst.TabControl.ActivatePage(PanelSceneInst.NetworkTab, GetBestPlayerIndex());
	PanelSceneInst.OnSceneDeactivated = SettingsSceneClosed;
	PanelSceneInst.OnNotifyOptionChanged = OnSettingValueChanged;
}
function SettingsSceneClosed( UIScene DeactivatedScene )
{
	if ( bProfileNeedsSaving )
	{
		MarkProfileDirty(false);
		UTGameUISceneClient(GetSceneClient()).ShowSaveProfileScene(GetUTPlayerOwner());
	}

	PerformMultiplayerChecks();
}

/** Handler for the OnOptionChanged delegate of the first time settings panel; called when the user changes the value for an option */
function OnSettingValueChanged(UIScreenObject InObject, name OptionName, int PlayerIndex)
{
	local UIDataStorePublisher Publisher;
	local array<UIDataStore> Unused;

	Publisher = UIDataStorePublisher(InObject);
	if ( Publisher != None )
	{
		Publisher.SaveSubscriberValue(Unused);
	}
}

/**
 * Called when the profile has been modified and needs to be saved.
 */
function MarkProfileDirty( optional bool bDirty=true )
{
	bProfileNeedsSaving = bDirty;
}

/** Displays a messagebox if the player doesn't have a custom character set. */
function DisplayNewPlayerMessageBox()
{
	local UTUIScene_MessageBox MessageBoxReference;
	local array<string> MessageBoxOptions;
	local array<PotentialOptionKeys> PotentialOptionKeyMappings;

	if( !HasSavedCharacterData() )
	{
		if ( GetWorldInfo().IsDemoBuild() )	// In demo builds just generate a random character.
		{
			OnFirstTimeCharacter_Confirm(None,0,GetPlayerIndex());
		}
		else
		{
			// Pop up a message box asking the user if they want to edit their character or randomly generate one.
			MessageBoxReference = GetMessageBoxScene();

			if(MessageBoxReference != none)
			{
				MessageBoxOptions.AddItem("<Strings:UTGameUI.CharacterCustomization.RandomlyGenerate>");
				MessageBoxOptions.AddItem("<Strings:UTGameUI.CharacterCustomization.CreateCharacter>");
				MessageBoxOptions.AddItem("<Strings:UTGameUI.Generic.Cancel>");

				PotentialOptionKeyMappings.length = 3;
				PotentialOptionKeyMappings[0].Keys.AddItem('XboxTypeS_X');
				PotentialOptionKeyMappings[1].Keys.AddItem('XboxTypeS_A');
				PotentialOptionKeyMappings[2].Keys.AddItem('XboxTypeS_B');
				PotentialOptionKeyMappings[2].Keys.AddItem('Escape');

				MessageBoxReference.SetPotentialOptionKeyMappings(PotentialOptionKeyMappings);
				MessageBoxReference.SetPotentialOptions(MessageBoxOptions);
				MessageBoxReference.Display("<Strings:UTGameUI.MessageBox.FirstTimeCharacter_Message>", "<Strings:UTGameUI.MessageBox.FirstTimeCharacter_Title>", OnFirstTimeCharacter_Confirm);
			}
		}
	}
}

/**
 * Callback when the user dismisses the firsttime character message box.
 */

function OnFirstTimeCharacter_Confirm(UTUIScene_MessageBox MessageBox, int SelectedOption, int PlayerIndex)
{
	local CustomCharData CustomData;
	local string DataString;

	switch ( SelectedOption )
	{
	case 0:	// Randomly generate a character
		CustomData = class'UTCustomChar_Data'.static.MakeRandomCharData();
		DataString = class'UTCustomChar_Data'.static.CharDataToString(CustomData);
		if(SetDataStoreStringValue("<OnlinePlayerData:ProfileData.CustomCharData>", DataString, Self, GetPlayerOwner()))
		{
			UTGameUISceneClient(GetSceneClient()).ShowSaveProfileScene(GetUTPlayerOwner());
			MarkProfileDirty(false);
		}
		break;

	case 1:	// Open the character selection scene
		OpenSceneByName(CharacterSelectionScene);
		bDisplayedNewPlayerMessageBox=false;	// Need to recheck for a customized character after the user has closed the player customization screen.
		break;
	case 2:	// Close this scene
		CloseScene(self);
		break;
	}
}

/**
 * Executes a action based on the currently selected menu item.
 */
function OnSelectItem(int PlayerIndex=GetPlayerIndex())
{
	local int SelectedItem, ControllerId;
	local UTUIDataStore_StringList StringListDataStore;
	local DataStoreClient DSClient;

	DSClient = class'UIInteraction'.static.GetDataStoreClient();
	if ( DSClient != None )
	{
		StringListDataStore = UTUIDataStore_StringList(DSClient.FindDataStore('UTStringList'));
	}

	SelectedItem = MenuList.GetCurrentItem();
	ControllerId = class'UIInteraction'.static.GetPlayerControllerId(PlayerIndex);
	switch(SelectedItem)
	{
	case MULTIPLAYER_OPTION_QUICKMATCH:
		if ( CheckLinkConnectionAndError() && CheckLoginAndError(ControllerId, true) )
		{
			OpenSceneByName(QuickMatchScene);
		}
		break;

	case MULTIPLAYER_OPTION_HOSTGAME:
		if ( CheckLinkConnectionAndError() )
		{
			OpenSceneByName(HostScene);
		}
		break;

	case MULTIPLAYER_OPTION_JOINGAME:
		if ( CheckLinkConnectionAndError() && CheckLoginAndError(ControllerId, true) )
		{
			StringListDataStore.SetCurrentValueIndex('MatchType', 1);
			OpenSceneByName(Joinscene);
		}
		break;

	case MULTIPLAYER_OPTION_JOINGAMELAN:
		if ( CheckLinkConnectionAndError() )
		{
			StringListDataStore.SetCurrentValueIndex('MatchType', 0);
			OpenSceneByName(Joinscene, false, OnJoinLanScene_Opened);
		}
		break;
	}
}


/** Callback for when the join scene has opened for LAN. */
function OnJoinLanScene_Opened(UIScene OpenedScene, bool bInitialActivation)
{
	local UTUIFrontEnd_JoinGame JoinSceneInst;

	// Set a string value to indicate that this is a LAN client, so the
	// UI is aware of this after we disconnect from the server
	SetDataStoreStringValue("<Registry:LanClient>", "1");

	JoinSceneInst = UTUIFrontEnd_JoinGame(OpenedScene);	 
	if ( JoinSceneInst != none && bInitialActivation )
	{
		JoinSceneInst.UseLANMode();
	}
}

defaultproperties
{
   QuickMatchScene="UI_Scenes_ChrisBLayout.Scenes.QuickMatch"
   HostScene="UI_Scenes_ChrisBLayout.Scenes.HostGame"
   JoinScene="UI_Scenes_FrontEnd.Scenes.JoinGame"
   CharacterSelectionScene="UI_Scenes_ChrisBLayout.Scenes.CharacterFaction"
   SettingsPanelsScene="UI_Scenes_ChrisBLayout.Scenes.SettingsPanels"
   bRequiresNetwork=True
   bMenuLevelRestoresScene=True
   Begin Object Class=UIComp_Event Name=SceneEventComponent ObjName=SceneEventComponent Archetype=UIComp_Event'UTGame.Default__UTUIFrontEnd_BasicMenu:SceneEventComponent'
      ObjectArchetype=UIComp_Event'UTGame.Default__UTUIFrontEnd_BasicMenu:SceneEventComponent'
   End Object
   EventProvider=SceneEventComponent
   Name="Default__UTUIFrontEnd_Multiplayer"
   ObjectArchetype=UTUIFrontEnd_BasicMenu'UTGame.Default__UTUIFrontEnd_BasicMenu'
}