1926 lines
54 KiB
Ucode
1926 lines
54 KiB
Ucode
//=============================================================================
|
|
// KFGFxMenu_StartGame
|
|
//=============================================================================
|
|
// Class Description
|
|
//=============================================================================
|
|
// Killing Floor 2
|
|
// Copyright (C) 2015 Tripwire Interactive LLC
|
|
// - Author 4/23/2014
|
|
//=============================================================================
|
|
|
|
class KFGFxMenu_StartGame extends KFGFxObject_Menu
|
|
dependson(TWOnlineLobby)
|
|
config(UI)
|
|
native(UI);
|
|
|
|
`include(KFProfileSettings.uci)
|
|
|
|
var string WhatsNewPS;
|
|
var string WhatsNewMS;
|
|
var string WhatsNewSteam;
|
|
|
|
var bool bIsLeader;
|
|
var bool bIsInParty;
|
|
var bool bSearchingForGame;
|
|
var bool bLeaderInServerBrowser, bLeaderWasInServerBrowser;
|
|
|
|
var bool bPendingLeaveMenu;
|
|
|
|
var transient bool AttemptingJoin;
|
|
var transient bool bAttemptingServerCreate;
|
|
var transient int CurrentSearchIndex;
|
|
|
|
var const string ModeKey, DifficultyKey, MapKey, WhitelistedKey, InProgressKey, PermissionsKey, ServerTypeKey;
|
|
var const string GameLengthKey;
|
|
|
|
var KFGFxStartGameContainer_FindGame FindGameContainer;
|
|
var KFGFxStartGameContainer_Options OptionsComponent;
|
|
var KFGFxStartContainer_InGameOverview OverviewContainer;
|
|
var KFGFxStartContainer_ServerBrowserOverview ServerBrowserOverviewContainer;
|
|
var KFGFxStartContainer_NewsImageHolder NewsImageHolderContainer;
|
|
|
|
var KFGFxMissionObjectivesContainer MissionObjectiveContainer;
|
|
|
|
|
|
|
|
//@HSL_BEGIN - JRO - 4/28/2016 - Disable certain features for PlayGo
|
|
var GFxObject CreateGameButton;
|
|
var GFxObject MatchMakingButton;
|
|
var GFxObject ServerBrowserButton;
|
|
//@HSL_END
|
|
|
|
var bool bHarrassedPlayerAboutSharedContent;
|
|
|
|
var localized string FindGameString;
|
|
var localized string HostOptionsString;
|
|
var localized string OverviewString;
|
|
|
|
var localized string MatchmakingString;
|
|
var localized string CreateMatchString;
|
|
var localized string ServerBrowserString;
|
|
var localized string NewsPageString;
|
|
|
|
var localized string GameModeTitle;
|
|
var localized string DifficultyTitle;
|
|
var localized string LengthTitle;
|
|
var localized string MapTitle;
|
|
var localized string MutatorTitle;
|
|
var localized string PermissionsTitle;
|
|
var localized string ServerTypeString;
|
|
var localized string WhiteListedTitle;
|
|
var localized string InfoTitle;
|
|
var localized string InProgressString;
|
|
|
|
var localized string LeaveMenuString;
|
|
|
|
var localized string CouldNotFindGameTitleString;
|
|
|
|
//Do not use these directly! Use the GetCouldNotFindGameDescription() function
|
|
//to pick between them based on platform
|
|
var private localized string CouldNotFindGameDescriptionStringPC;
|
|
var private localized string CouldNotFindGameDescriptionStringOrbis;
|
|
|
|
//Match Making
|
|
var localized array<string> WhiteListedStrings;
|
|
|
|
/** Name of the search datastore, for finding a server to take over. */
|
|
var protected transient const name SearchDSName;
|
|
/** Reference to the search datastore, for finding a server to take over. */
|
|
var transient KFDataStore_OnlineGameSearch SearchDataStore;
|
|
/** Cached game interface pointer, for finding a server to take over. */
|
|
var transient OnlineGameInterface GameInterface;
|
|
|
|
var array<string> MapStringList;
|
|
|
|
var config bool AttemptServerTakeovers;
|
|
var transient string MapTakeoverURL;
|
|
var transient string PendingResolvedAddress;
|
|
|
|
var string CurrentPartyLeaderName;
|
|
|
|
var transient bool bPauseTryingServers;
|
|
|
|
/** How long to collect servers before sorting them and starting to try to connect */
|
|
var config float InitialSearchPause;
|
|
|
|
/** How many results to quit after (passed to OnlineSubsystem) */
|
|
var config int MaxResultsToTry;
|
|
|
|
/** How long to wait for a server to respond to "open" before giving up on it. */
|
|
var config int ServerConnectTimeout;
|
|
var config int ServerTakeoverTimeout;
|
|
|
|
/** Whether to log information about searching for games */
|
|
var config bool bLogSearchInfo;
|
|
|
|
var config array<string> StockMaps;
|
|
|
|
var transient bool SearchFinished;
|
|
|
|
/** When taking over a server, holds the password set or auto-generated for
|
|
the server being taken over, for privacy */
|
|
var transient string LobbyOwnerPassword;
|
|
var config string TestLobbyOwnerPassword;
|
|
|
|
/** Keeps the current map of the server you are trying to connect to, which might be useful
|
|
if you're doing a server takeover but have the map "filter" set to "Any" */
|
|
var transient string CurrentConnectMap;
|
|
|
|
/** If we didn't boot up installing, we don't really need to do installation checks */
|
|
var transient bool bIsPlayGoRun;
|
|
|
|
native static function GetMapList( out array<string> MapList, optional int OverrideGameModeIndex = INDEX_NONE, optional bool bStockMapsOnly );
|
|
|
|
cpptext
|
|
{
|
|
UBOOL DoesGamemodeSupportMap(INT GameModeIndex, const FString& MapName);
|
|
}
|
|
|
|
function InitializeMenu( KFGFxMoviePlayer_Manager InManager )
|
|
{
|
|
local DataStoreClient DSClient;
|
|
|
|
super.InitializeMenu(InManager);
|
|
SetSeasonalEventClass(); //based of seasonal event ID
|
|
|
|
// Initializations so we can search for a dedicated server to take over
|
|
DSClient = class'UIInteraction'.static.GetDataStoreClient();
|
|
if ( DSClient != None )
|
|
{
|
|
SearchDataStore = KFDataStore_OnlineGameSearch(DSClient.FindDataStore(SearchDSName));
|
|
}
|
|
if(class'GameEngine'.static.GetOnlineSubsystem() != none)
|
|
{
|
|
GameInterface = class'GameEngine'.static.GetOnlineSubsystem().GameInterface;
|
|
|
|
//@HSL_BEGIN - JRO - 4/28/2016 - Show a message when we're still installing
|
|
bIsPlayGoRun = !class'GameEngine'.static.IsGameFullyInstalled();
|
|
if( bIsPlayGoRun )
|
|
{
|
|
Manager.DelayedOpenPopup(ENotification,EDPPID_Misc, Localize("Notifications", "PlayGoBusyTitle", "KFGameConsole"), Localize("Notifications", "PlayGoBusyMessage", "KFGameConsole"), class'KFCommon_LocalizedStrings'.default.OKString);
|
|
}
|
|
}
|
|
setVivoxWordmarkVisibility();
|
|
}
|
|
|
|
//@SABER_EGS_BEGIN show vivox wordmark
|
|
function setVivoxWordmarkVisibility()
|
|
{
|
|
if (isPC() && isMultiplayerGame())
|
|
{
|
|
GetObject("wordmarkVivox").setVisible(true);
|
|
}
|
|
else
|
|
{
|
|
GetObject("wordmarkVivox").setVisible(false);
|
|
}
|
|
}
|
|
|
|
function bool isPC()
|
|
{
|
|
return !class'WorldInfo'.static.IsConsoleBuild();
|
|
}
|
|
|
|
function bool IsMultiplayerGame()
|
|
{
|
|
return GetPC().WorldInfo.NetMode != NM_Standalone;
|
|
}
|
|
//@SABER_EGS_END
|
|
|
|
function SetSeasonalEventClass()
|
|
{
|
|
local GFXWidgetBinding MyWidgetBinding;
|
|
|
|
MyWidgetBinding.WidgetName ='specialEventContainerMC';
|
|
MyWidgetBinding.WidgetClass=GetSpecialEventClass(class'KFGameEngine'.static.GetSeasonalEventId());
|
|
|
|
SubWidgetBindings[8]=MyWidgetBinding;
|
|
}
|
|
|
|
static function class<KFGFxSpecialeventObjectivesContainer> GetSpecialEventClass(int SpecialEventID)
|
|
{
|
|
switch (SpecialEventID)
|
|
{
|
|
case SEI_Spring:
|
|
return class'KFGFxSpecialEventObjectivesContainer_Spring2020';
|
|
case SEI_Summer:
|
|
return class'KFGFxSpecialEventObjectivesContainer_Summer2020';
|
|
case SEI_Fall:
|
|
return class'KFGFxSpecialEventObjectivesContainer_Fall2020';
|
|
case SEI_Winter:
|
|
return class'KFGFXSpecialEventObjectivesContainer_Xmas2020';
|
|
}
|
|
|
|
return class'KFGFxSpecialEventObjectivesContainer';
|
|
}
|
|
|
|
/** Ties the GFxClikWidget variables to the .swf components and handles events */
|
|
event bool WidgetInitialized(name WidgetName, name WidgetPath, GFxObject Widget)
|
|
{
|
|
switch(WidgetName)
|
|
{
|
|
case('newsPage'):
|
|
|
|
if (NewsImageHolderContainer == none)
|
|
{
|
|
NewsImageHolderContainer = KFGFxStartContainer_NewsImageHolder(Widget);
|
|
NewsImageHolderContainer.Initialize(self);
|
|
}
|
|
break;
|
|
//mission objectives UI
|
|
case ('missionObjectivesContainerMC'):
|
|
|
|
if(MissionObjectiveContainer == none)
|
|
{
|
|
MissionObjectiveContainer = KFGFxMissionObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('dailyContainerMC'):
|
|
if(MissionObjectiveContainer.ExpandedObjectiveContainer.DailyObjectiveContainer == none)
|
|
{
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.DailyObjectiveContainer = KFGFxDailyObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.DailyObjectiveContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('expandedMissionObjectivesMC'):
|
|
|
|
if(MissionObjectiveContainer.ExpandedObjectiveContainer == none) //this is not the normal way we do this. This is a special case
|
|
{
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer = KFGFxExpandedObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('collapsedMissionObjectivesMC'):
|
|
|
|
if(MissionObjectiveContainer.CollapsedObjectiveContainer == none)
|
|
{
|
|
MissionObjectiveContainer.CollapsedObjectiveContainer = KFGFxCollapsedObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.CollapsedObjectiveContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('specialEventContainerMC'):
|
|
|
|
if(MissionObjectiveContainer.ExpandedObjectiveContainer.SpecialEventsContainer == none)
|
|
{
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.SpecialEventsContainer = KFGFxSpecialEventObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.SpecialEventsContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('weeklyContainerMC'):
|
|
|
|
if(MissionObjectiveContainer.ExpandedObjectiveContainer.WeeklyEventContainer == none)
|
|
{
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.WeeklyEventContainer = KFGFxWeeklyObjectivesContainer(Widget);
|
|
MissionObjectiveContainer.ExpandedObjectiveContainer.WeeklyEventContainer.Initialize( self );
|
|
}
|
|
break;
|
|
//end mission objectives UI
|
|
case ('findGameContainer'):
|
|
if ( FindGameContainer == none )
|
|
{
|
|
FindGameContainer = KFGFxStartGameContainer_FindGame( Widget );
|
|
FindGameContainer.Initialize( self );
|
|
}
|
|
break;
|
|
case ('gameOptionsContainer'):
|
|
if ( OptionsComponent == none )
|
|
{
|
|
OptionsComponent = KFGFxStartGameContainer_Options( Widget );
|
|
OptionsComponent.Initialize( self );
|
|
}
|
|
break;
|
|
case ('overviewContainer'):
|
|
if ( OverviewContainer == none )
|
|
{
|
|
OverviewContainer = KFGFxStartContainer_InGameOverview( Widget );
|
|
OverviewContainer.Initialize( self );
|
|
SetOverview(true);
|
|
}
|
|
break;
|
|
case ('serverBrowserOverviewContainer'):
|
|
if ( ServerBrowserOverviewContainer == none )
|
|
{
|
|
ServerBrowserOverviewContainer = KFGFxStartContainer_ServerBrowserOverview( Widget );
|
|
ServerBrowserOverviewContainer.Initialize( self );
|
|
}
|
|
break;
|
|
//@HSL_BEGIN - JRO - 4/28/2016 - Disable certain features for PlayGo
|
|
case ('matchMakingButton'):
|
|
MatchMakingButton = Widget;
|
|
if(class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
CheckGameFullyInstalled();
|
|
}
|
|
break;
|
|
case ('createGameButton'):
|
|
CreateGameButton = Widget;
|
|
if (class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
CheckGameFullyInstalled();
|
|
}
|
|
break;
|
|
case ('serverBrowserButton'):
|
|
ServerBrowserButton = Widget;
|
|
if(class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
CheckGameFullyInstalled();
|
|
}
|
|
break;
|
|
//@HSL_END
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function string GetCouldNotFindGameDescription()
|
|
{
|
|
if (class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
return CouldNotFindGameDescriptionStringOrbis;
|
|
}
|
|
else
|
|
{
|
|
return CouldNotFindGameDescriptionStringPC;
|
|
}
|
|
}
|
|
|
|
|
|
//@HSL_BEGIN - JRO - 4/28/2016 - Disable certain features for PlayGo
|
|
function CheckGameFullyInstalled()
|
|
{
|
|
if(bIsPlayGoRun)
|
|
{
|
|
if( class'GameEngine'.static.IsGameFullyInstalled() )
|
|
{
|
|
if (MatchMakingButton != none)
|
|
{
|
|
MatchMakingButton.SetBool("enabled", true);
|
|
}
|
|
if(CreateGameButton != none)
|
|
{
|
|
CreateGameButton.SetBool("enabled", true);
|
|
}
|
|
if (ServerBrowserButton != none)
|
|
{
|
|
ServerBrowserButton.SetBool("enabled", true);
|
|
}
|
|
InitializeMenu(Manager);
|
|
ReloadSounds();
|
|
}
|
|
else
|
|
{
|
|
if (MatchMakingButton != none)
|
|
{
|
|
MatchMakingButton.SetBool("enabled", false);
|
|
}
|
|
if (CreateGameButton != none)
|
|
{
|
|
CreateGameButton.SetBool("enabled", false);
|
|
}
|
|
if (ServerBrowserButton != none)
|
|
{
|
|
ServerBrowserButton.SetBool("enabled", false);
|
|
}
|
|
`TimerHelper.SetTimer(1.0f, false, nameof(CheckGameFullyInstalled), self);
|
|
}
|
|
}
|
|
}
|
|
|
|
native function ReloadSounds();
|
|
//@HSL_END
|
|
|
|
|
|
// OVERVIEW, OVERVIEW_SERVER_BROWSER
|
|
function SetOverview(optional bool bInitialize)
|
|
{
|
|
local UniqueNetId AdminId, MyUID, ZeroId;
|
|
local bool bCurrentlyLeader;
|
|
local bool bCurrentlyInParty;
|
|
|
|
if (OverviewContainer != none)
|
|
{
|
|
OverviewContainer.UpdateOverviewInGame();
|
|
}
|
|
|
|
if(OnlineLobby != none)
|
|
{
|
|
MyUID = OnlineLobby.GetMyId();
|
|
OnlineLobby.GetLobbyAdmin(OnlineLobby.GetCurrentLobbyId(), AdminId);
|
|
|
|
bCurrentlyLeader = (MyUID == AdminId && MyUID != ZeroId);
|
|
bCurrentlyInParty = OnlineLobby.IsInLobby();
|
|
}
|
|
|
|
// Update what our start game looks like if any important options have changed
|
|
if ( bIsLeader != bCurrentlyLeader || bCurrentlyInParty != bIsInParty || bInitialize || bLeaderInServerBrowser != bLeaderWasInServerBrowser )
|
|
{
|
|
bIsLeader = bCurrentlyLeader;
|
|
bIsInParty = bCurrentlyInParty;
|
|
bLeaderWasInServerBrowser = bLeaderInServerBrowser;
|
|
if (class'WorldInfo'.static.IsMenuLevel())
|
|
{
|
|
if (bIsInParty)
|
|
{
|
|
if(bIsLeader)
|
|
{
|
|
if(Manager.CurrentMenuIndex == UI_ServerBrowserMenu)
|
|
{
|
|
ShowOverview(false, bIsLeader, class'WorldInfo'.static.IsMenuLevel(), false);
|
|
Manager.OpenMenu(UI_ServerBrowserMenu);
|
|
}
|
|
else
|
|
{
|
|
ShowOverview(false, bIsLeader, class'WorldInfo'.static.IsMenuLevel(), false);
|
|
//OpenMultiplayerMenu();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowOverview(!bIsLeader, bIsLeader, class'WorldInfo'.static.IsMenuLevel(), bLeaderInServerBrowser);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowOverview(true, bIsLeader, false, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Send the player back to the start menu and open the shared content object if there is content to share and we are not in standalone
|
|
function OnPlayerReadiedUp()
|
|
{
|
|
local PlayerController PC;
|
|
|
|
PC = GetPC();
|
|
if(bHarrassedPlayerAboutSharedContent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(OverviewContainer != none && OverviewContainer.bContentShared && PC.WorldInfo.NetMode != NM_Standalone )
|
|
{
|
|
if(Manager.CurrentMenuIndex != UI_Start)
|
|
{
|
|
Manager.OpenMenu(UI_Start);
|
|
}
|
|
|
|
// Consoles don't show this screen. HSL_BB
|
|
if ( !PC.WorldInfo.IsConsoleBuild() )
|
|
{
|
|
OverviewContainer.ActionScriptVoid("showSharedContentList");
|
|
}
|
|
}
|
|
bHarrassedPlayerAboutSharedContent = true;
|
|
}
|
|
|
|
function OneSecondLoop()
|
|
{
|
|
SetOverview();
|
|
if(Manager.CurrentMenuIndex != UI_IIS)
|
|
{
|
|
UpdateMenu();
|
|
}
|
|
|
|
if(OverviewContainer != none && Manager.CurrentMenu == self)
|
|
{
|
|
OverviewContainer.UpdateSharedContent();
|
|
}
|
|
|
|
if (FindGameContainer != none)
|
|
{
|
|
FindGameContainer.CheckNewsState();
|
|
}
|
|
|
|
}
|
|
|
|
//==============================================================
|
|
// Get Functions
|
|
//==============================================================
|
|
|
|
function byte GetStartMenuState()
|
|
{
|
|
return GetInt("menuState");
|
|
}
|
|
|
|
//get the map's image path from the dataProvider and set it in flash.
|
|
function string GetMapSource(string MapName)
|
|
{
|
|
local KFMapSummary MapData;
|
|
|
|
MapData = class'KFUIDataStore_GameResource'.static.GetMapSummaryFromMapName(MapName);
|
|
if ( MapData != none )
|
|
{
|
|
//`log(MapData.ScreenshotPathName);
|
|
return "img://" $MapData.ScreenshotPathName;
|
|
}
|
|
else
|
|
{
|
|
// Failed to find map image, use the default instead
|
|
MapData = class'KFUIDataStore_GameResource'.static.GetMapSummaryFromMapName("KF-Default");
|
|
if ( MapData != none )
|
|
{
|
|
return "img://" $MapData.ScreenshotPathName;
|
|
}
|
|
}
|
|
}
|
|
|
|
//==============================================================
|
|
// Component Functions
|
|
//==============================================================
|
|
//When the leader of the lobby is either changed or assigned.
|
|
function HandleSteamLobbyLeaderTakeOver(UniqueNetId AdminId)
|
|
{
|
|
local bool bClientIsLeader;
|
|
|
|
bClientIsLeader = GetPC().PlayerReplicationInfo.UniqueId == AdminId;
|
|
switch (GetStartMenuState())
|
|
{
|
|
case EServerBrowserOverview:
|
|
if(bClientIsLeader)
|
|
{
|
|
Manager.OpenMenu(UI_ServerBrowserMenu);
|
|
return;
|
|
}
|
|
default:
|
|
if (bClientIsLeader)
|
|
{
|
|
Manager.SetStartMenuState(EStartHome);
|
|
SetInt("externalMenuState", EStartHome);
|
|
//Manager.OpenMenu(UI_Start);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(!bClientIsLeader)
|
|
{
|
|
SendToOverviewOnChange();
|
|
}
|
|
}
|
|
|
|
function SendToOverviewOnChange()
|
|
{
|
|
Manager.SetStartMenuState(EOverview);
|
|
Manager.OpenMenu(UI_Start);
|
|
SetOverview(true);
|
|
}
|
|
|
|
// Make sure our menu information is up to date
|
|
function UpdateMenu()
|
|
{
|
|
local UniqueNetId AdminId;
|
|
local UniqueNetId LoggedInPlayer;
|
|
|
|
if ( class'WorldInfo'.static.IsMenuLevel() && OnlineLobby != none && OnlineLobby.IsInLobby() )
|
|
{
|
|
OnlineLobby.GetLobbyAdmin( OnlineLobby.GetCurrentLobbyId(), AdminId );
|
|
LoggedInPlayer = OnlineLobby.GetMyId();
|
|
if ( LoggedInPlayer == AdminId )
|
|
{
|
|
// We are the party leader
|
|
SendLeaderOptions();
|
|
}
|
|
else
|
|
{
|
|
// We are a party member
|
|
ReceiveLeaderOptions();
|
|
CurrentPartyLeaderName = OnlineLobby.GetFriendNickname(AdminId);
|
|
if(CurrentPartyLeaderName != "")
|
|
{
|
|
ServerBrowserOverviewContainer.SetDescriptionString(CurrentPartyLeaderName);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// As the leader of the party, make sure the members have the latest information
|
|
function SendLeaderOptions()
|
|
{
|
|
if (OptionsComponent != none)
|
|
{
|
|
SetLobbyData(GameLengthKey, String(OptionsComponent.GetLengthIndex()));
|
|
SetLobbyData(DifficultyKey, String(OptionsComponent.GetDifficultyIndex()));
|
|
SetLobbyData(MapKey, OptionsComponent.GetMapName());
|
|
SetLobbyData(ModeKey, String(Manager.GetModeIndex()));
|
|
SetLobbyData(PermissionsKey, String(OptionsComponent.GetPrivacyIndex()));
|
|
}
|
|
}
|
|
|
|
// As a member of party, check to see if your options are different than the party leaders
|
|
function ReceiveLeaderOptions()
|
|
{
|
|
local string OptionString;
|
|
local string DisplayMapName, MapSource;
|
|
local int OptionIndex;
|
|
|
|
OptionIndex = Int(OnlineLobby.GetLobbyData(0, ModeKey));
|
|
OverviewContainer.UpdateGameMode(class'KFCommon_LocalizedStrings'.static.GetGameModeString(OptionIndex));
|
|
|
|
OptionIndex = Int(OnlineLobby.GetLobbyData(0, GameLengthKey));
|
|
OverviewContainer.UpdateLength(class'KFCommon_LocalizedStrings'.static.GetLengthString(OptionIndex));
|
|
|
|
OptionIndex = Int(OnlineLobby.GetLobbyData(0, ServerTypeKey));
|
|
OverviewContainer.UpdateServerType(class'KFCommon_LocalizedStrings'.static.GetServerTypeString(OptionIndex));
|
|
|
|
OptionIndex = Int(OnlineLobby.GetLobbyData(0, DifficultyKey));
|
|
OverviewContainer.UpdateDifficulty(class'KFCommon_LocalizedStrings'.static.GetDifficultyString(OptionIndex));
|
|
|
|
OptionString = OnlineLobby.GetLobbyData(0, MapKey);
|
|
DisplayMapName = class'KFCommon_LocalizedStrings'.static.GetFriendlyMapName(OptionString);
|
|
MapSource = GetMapSource(OptionString);
|
|
OverviewContainer.UpdateMap( DisplayMapName, MapSource );
|
|
|
|
OptionIndex = Int(OnlineLobby.GetLobbyData(0, PermissionsKey));
|
|
OverviewContainer.UpdatePrivacy(class'KFCommon_LocalizedStrings'.static.GetPermissionString(OptionIndex));
|
|
}
|
|
|
|
function ApproveMatchMakingLeave()
|
|
{
|
|
if(OptionsComponent != none)
|
|
{
|
|
bPendingLeaveMenu = false;
|
|
if( OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
OnlineLobby.QuitLobby();
|
|
}
|
|
CancelGameSearch();
|
|
|
|
SetInt("externalMenuState", EStartHome);
|
|
UpdateStartMenuState();
|
|
|
|
}
|
|
}
|
|
|
|
function GoToServerBrowser()
|
|
{
|
|
Manager.OpenMenu(UI_ServerBrowserMenu);
|
|
}
|
|
|
|
function CancelLeaveMenu()
|
|
{
|
|
GetPC().SetTimer(0.5f, false, nameof(ClearLeaveMenuFlag), self);
|
|
}
|
|
|
|
function ClearLeaveMenuFlag()
|
|
{
|
|
bPendingLeaveMenu = false;
|
|
}
|
|
|
|
function UpdateStartMenuState()
|
|
{
|
|
local byte CurrentMenuState;
|
|
|
|
if( Manager != none )
|
|
{
|
|
CurrentMenuState = GetStartMenuState();
|
|
Manager.SetStartMenuState(EStartMenuState(CurrentMenuState));
|
|
Switch(EStartMenuState(CurrentMenuState))
|
|
{
|
|
case ECreateGame:
|
|
OptionsComponent.bShowLengthNoPref = false;
|
|
OptionsComponent.InitializeGameOptions();
|
|
break;
|
|
case EMatchmaking:
|
|
OptionsComponent.bShowLengthNoPref = true;
|
|
OptionsComponent.InitializeGameOptions();
|
|
//set match privacy to public for find match
|
|
OptionsComponent.PrivacyChanged(0);
|
|
break;
|
|
case ESoloGame:
|
|
OptionsComponent.bShowLengthNoPref = false;
|
|
OptionsComponent.InitializeGameOptions();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
function ProceedToTutorial()
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
OnlineLobby.QuitLobby();
|
|
}
|
|
}
|
|
|
|
CancelGameSearch();
|
|
|
|
ConsoleCommand("open KF-EvacuationPoint?game=KFGameContent.KFGameInfo_Tutorial");
|
|
}
|
|
|
|
function ProceedToSoloMenu()
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
OnlineLobby.QuitLobby();
|
|
}
|
|
}
|
|
|
|
//set create party button invisible.
|
|
Manager.SoloGameMenuOpened();
|
|
|
|
CancelGameSearch();
|
|
|
|
SetInt("externalMenuState", ESoloGame);
|
|
}
|
|
|
|
function PostPartyDisbandTutorial()
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
OnlineLobby.QuitLobby();
|
|
}
|
|
}
|
|
|
|
CancelGameSearch();
|
|
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, class'KFCommon_LocalizedStrings'.default.ProceedToTutorialString, class'KFCommon_LocalizedStrings'.default.ProceedToTutorialDescriptionString, class'KFCommon_LocalizedStrings'.default.ConfirmString, class'KFCommon_LocalizedStrings'.default.CancelString, ProceedToTutorial);
|
|
}
|
|
|
|
//==============================================================
|
|
// ActionScript Callbacks
|
|
//==============================================================
|
|
|
|
function Callback_OnWhatsNewClicked(int Index, string URL)
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
local int i;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if(OnlineSub != none)
|
|
{
|
|
if(Class'WorldInfo'.Static.IsConsoleBuild())
|
|
{
|
|
if (Class'WorldInfo'.Static.IsConsoleBuild(CONSOLE_Orbis) && !OnlineSub.IsGameOwned())
|
|
{
|
|
Manager.OnBuyGamePressed();
|
|
return;
|
|
}
|
|
// If this is attached to a PSN product ID, we need to look up the signed offer Id
|
|
if( FindGameContainer.PS4ActiveWhatsNewItems[Index].PSNProductId != "" )
|
|
{
|
|
for( i = 0; i < OnlineSub.ItemPropertiesList.Length; i++ )
|
|
{
|
|
if( OnlineSub.ItemPropertiesList[i].ProductId == FindGameContainer.PS4ActiveWhatsNewItems[Index].PSNProductId )
|
|
{
|
|
if( OnlineSub.ItemPropertiesList[i].SignedOfferId != "" )
|
|
{
|
|
if( class'WorldInfo'.static.IsConsoleBuild( CONSOLE_Orbis ) )
|
|
{
|
|
OnlineSub.OpenMarketPlaceSearch( OnlineSub.ItemPropertiesList[i] );
|
|
}
|
|
else
|
|
{
|
|
OnlineSub.PlayerInterfaceEx.ShowProductDetailsUI( GetLP().ControllerId, OnlineSub.ItemPropertiesList[i].ProductId );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
`warn("No PSN signed offer ID for item with product ID"@FindGameContainer.PS4ActiveWhatsNewItems[Index].PSNProductId);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if( FindGameContainer.PS4ActiveWhatsNewItems[Index].RedirectURL != "" )
|
|
{
|
|
OnlineSub.OpenURL( FindGameContainer.PS4ActiveWhatsNewItems[Index].RedirectURL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnlineSub.OpenURL(URL);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
function Callback_NewsButtonPressed()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if (OnlineSub == none)
|
|
{
|
|
return;
|
|
}
|
|
if(class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Orbis))
|
|
{
|
|
OnlineSub.OpenURL(default.WhatsNewPS);
|
|
}
|
|
else if (class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Durango))
|
|
{
|
|
OnlineSub.OpenURL(default.WhatsNewMS);
|
|
}
|
|
else
|
|
{
|
|
OnlineSub.OpenURL(default.WhatsNewSteam);
|
|
}
|
|
|
|
}
|
|
|
|
function Callback_SoloButtonPressed()
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameString, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameDescriptionString,
|
|
Class'KFCommon_LocalizedStrings'.default.DisbandPartyString,
|
|
Class'KFCommon_LocalizedStrings'.default.CancelString, ProceedToSoloMenu); //middle button
|
|
}
|
|
else
|
|
{
|
|
ProceedToSoloMenu();
|
|
}
|
|
}
|
|
|
|
function Callback_StartTutorial()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
CancelGameSearch();
|
|
|
|
if (!OnlineSub.IsGameOwned() && class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Orbis))
|
|
{
|
|
if (OnlineSub.CanCheckFreeTrialState() && !OnlineSub.IsFreeTrialPeriodActive())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_BuyGame);
|
|
return;
|
|
}
|
|
|
|
if(!OnlineSub.CanCheckFreeTrialState())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_NetworkCheckFailed);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameString, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameDescriptionString,
|
|
Class'KFCommon_LocalizedStrings'.default.DisbandPartyString,
|
|
Class'KFCommon_LocalizedStrings'.default.CancelString, PostPartyDisbandTutorial); //middle button
|
|
}
|
|
else
|
|
{
|
|
//make pop up
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, class'KFCommon_LocalizedStrings'.default.ProceedToTutorialString, class'KFCommon_LocalizedStrings'.default.ProceedToTutorialDescriptionString, class'KFCommon_LocalizedStrings'.default.ConfirmString, class'KFCommon_LocalizedStrings'.default.CancelString, ProceedToTutorial);
|
|
}
|
|
}
|
|
|
|
function Callback_OnWebLinkClicked(string WebSiteLink)
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if(OnlineSub != none)
|
|
{
|
|
OnlineSub.OpenURL(WebSiteLink);
|
|
}
|
|
}
|
|
|
|
//Request to close the match making menu
|
|
function Callback_CancelSearch()
|
|
{
|
|
if( OptionsComponent != none )
|
|
{
|
|
CancelGameSearch();
|
|
GetPC().WorldInfo.CancelPendingMapChange();
|
|
KFGameEngine(Class'Engine'.static.GetEngine()).CancelPendingLevel();
|
|
}
|
|
}
|
|
|
|
//Callback
|
|
function Callback_OptionListOpened(string ListName, int OptionIndex)
|
|
{
|
|
local string MessageString;
|
|
|
|
if (OptionsComponent.bIsSoloGame && ListName == "modeList")
|
|
{
|
|
OptionIndex = OptionIndex >= 2 ? OptionIndex + 1 : OptionIndex;
|
|
}
|
|
|
|
if(ListName == "mapList" || GetPC().WorldInfo.IsConsoleBuild() && ListName == "regionList")
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(OptionIndex == INDEX_NONE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MessageString = Localize("StartMenuHelperText", ListName$OptionIndex, "KFGame");
|
|
|
|
if(OptionsComponent != none)
|
|
{
|
|
OptionsComponent.SetHelpText(MessageString);
|
|
}
|
|
}
|
|
|
|
function Callback_InGamePermissionChange( int Index )
|
|
{
|
|
if( OnlineLobby != none )
|
|
{
|
|
if( OnlineLobby.SetVisibility( Index ) && OptionsComponent != none )
|
|
{
|
|
OptionsComponent.PrivacyChanged( Index );
|
|
}
|
|
}
|
|
}
|
|
|
|
function Callback_OpenMatchMaking()
|
|
{
|
|
if(class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
KFPlayerController(GetPC()).StartLogin( ProceedToMatchMaking, true );
|
|
}
|
|
else
|
|
{
|
|
ProceedToMatchMaking();
|
|
}
|
|
}
|
|
|
|
function Callback_OpenCreateGame()
|
|
{
|
|
if (class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
KFPlayerController(GetPC()).StartLogin(ProceedToCreateGame, true);
|
|
}
|
|
else
|
|
{
|
|
ProceedToCreateGame();
|
|
}
|
|
}
|
|
|
|
// Call this to allow the player to go to the matchmaking screen on console.
|
|
function ProceedToMatchMaking()
|
|
{
|
|
SetInt("externalMenuState", EMatchmaking);
|
|
}
|
|
|
|
function ProceedToCreateGame()
|
|
{
|
|
SetInt("externalMenuState", ECreateGame);
|
|
}
|
|
|
|
function Callback_OpenServerBrowser()
|
|
{
|
|
if(class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
// BWJ - Disabled for console
|
|
// CanUseMultiplayerFeatures(OnCanPlayOnlineCheckComplete);
|
|
}
|
|
else
|
|
{
|
|
Manager.OpenMenu(UI_ServerBrowserMenu);
|
|
}
|
|
}
|
|
|
|
function OnCanPlayOnlineCheckComplete(byte LocalUserNum, EFeaturePrivilege Privilege, EFeaturePrivilegeLevel PrivilegeLevel, bool bDiffersFromHint)
|
|
{
|
|
// If it's not FP_OnlinePlay, we caught another async check that we don't care about...
|
|
if(Privilege == FP_OnlinePlay)
|
|
{
|
|
Class'GameEngine'.static.GetOnlineSubsystem().PlayerInterface.ClearPrivilegeLevelCheckedDelegate(OnCanPlayOnlineCheckComplete);
|
|
|
|
Manager.UnloadCurrentPopup();
|
|
|
|
if(PrivilegeLevel == FPL_Enabled)
|
|
{
|
|
Manager.OpenMenu(UI_ServerBrowserMenu);
|
|
}
|
|
else
|
|
{
|
|
Class'GameEngine'.static.GetOnlineSubsystem().PlayerInterfaceEx.UpsellPremiumOnlineService();
|
|
}
|
|
}
|
|
}
|
|
//@HSL_END
|
|
|
|
function Callback_StartMenuRequestReinit()
|
|
{
|
|
if( OptionsComponent != none )
|
|
{
|
|
OptionsComponent.bShowLengthNoPref = GetStartMenuState() == EMatchmaking;
|
|
OptionsComponent.InitializeGameOptions();
|
|
OptionsComponent.SetOptions(true);
|
|
}
|
|
}
|
|
|
|
function Callback_StartMenuChange()
|
|
{
|
|
UpdateStartMenuState();
|
|
}
|
|
|
|
function Callback_Mode( int Index )
|
|
{
|
|
OptionsComponent.ModeChanged( Index );
|
|
}
|
|
|
|
function Callback_Length( int Index )
|
|
{
|
|
OptionsComponent.LengthChanged( Index );
|
|
}
|
|
|
|
function Callback_Difficulty( int Index )
|
|
{
|
|
OptionsComponent.DifficultyChanged( Index );
|
|
}
|
|
|
|
function Callback_Privacy( int Index )
|
|
{
|
|
OptionsComponent.PrivacyChanged( Index );
|
|
}
|
|
|
|
function Callback_MapSelection( string MapKeyString )
|
|
{
|
|
local string MapName;
|
|
local int MapIndex;
|
|
|
|
MapIndex = MapStringList.Find(MapKeyString);
|
|
|
|
if(MapIndex == INDEX_NONE)
|
|
{
|
|
MapName = "";
|
|
}
|
|
else
|
|
{
|
|
MapName = MapKeyString;
|
|
}
|
|
|
|
OptionsComponent.MapChanged( MapName );
|
|
}
|
|
|
|
function Callback_Region(int RegionIndex)
|
|
{
|
|
OptionsComponent.SetRegionIndex(RegionIndex);
|
|
}
|
|
|
|
function SetLobbyData( string KeyName, string ValueData )
|
|
{
|
|
OnlineLobby.SetLobbyData( KeyName, ValueData );
|
|
}
|
|
|
|
function string MakeMapURL(KFGFxStartGameContainer_Options InOptionsComponent)
|
|
{
|
|
local string MapName;
|
|
local int LengthIndex, ModeIndex;
|
|
|
|
// this is ugly, but effectively makes sure that the player isn't solo with versus selected
|
|
// or other error cases such as when the game isn't fully installed
|
|
ModeIndex = InOptionsComponent.GetNormalizedGameModeIndex(Manager.GetModeIndex(true));
|
|
LengthIndex = InOptionsComponent.GetLengthIndex();
|
|
|
|
MapName = InOptionsComponent.GetMapName();
|
|
if (MapName == "" || MapStringList.Find(MapName) == INDEX_NONE)
|
|
{
|
|
if (CurrentConnectMap != "" && MapStringList.Find(CurrentConnectMap) != INDEX_NONE)
|
|
{
|
|
MapName = CurrentConnectMap;
|
|
}
|
|
else if( class'WorldInfo'.static.IsConsoleBuild() )
|
|
{
|
|
// Pick a random map is game is fully installed
|
|
if( class'GameEngine'.static.IsGameFullyInstalled() )
|
|
{
|
|
MapName = MapStringList[rand(MapStringList.Length)];
|
|
}
|
|
// evacuation point is the only map available if still installing
|
|
else
|
|
{
|
|
MapName = "KF-EvacuationPoint";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Biotics Lab doesn't support objective mode yet, so that needs a different default
|
|
if (ModeIndex == EGameMode_Objective)
|
|
{
|
|
MapName = "KF-SteamFortress";
|
|
}
|
|
else
|
|
{
|
|
MapName = "KF-BioticsLab";
|
|
}
|
|
}
|
|
}
|
|
|
|
return MapName$"?Game="$class'KFGameInfo'.static.GetGameModeClassFromNum( ModeIndex )
|
|
$"?Difficulty="$class'KFGameDifficultyInfo'.static.GetDifficultyValue( InOptionsComponent.GetDifficultyIndex() )
|
|
$"?GameLength="$LengthIndex;
|
|
}
|
|
|
|
native function bool GetSearchComplete(KFOnlineGameSearch GameSearch);
|
|
|
|
native function TryNextServer();
|
|
native function HandleSearchOver();
|
|
|
|
event OpenNotFoundPopup()
|
|
{
|
|
local KFPlayerController KFPC;
|
|
|
|
KFPC = KFPlayerController(GetPC());
|
|
`log("KFGFxMenu_StartGame.OpenNotFoundPopup: No servers found, giving up.");
|
|
KFPC.MyGFxManager.DelayedOpenPopup(ENotification, EDPPID_Misc, CouldNotFindGameTitleString, GetCouldNotFindGameDescription(), class'KFCommon_LocalizedStrings'.default.OKString);
|
|
}
|
|
|
|
event int GetLobbySize()
|
|
{
|
|
local ActiveLobbyInfo LobbyInfo;
|
|
|
|
if ( OnlineLobby == none || !OnlineLobby.GetCurrentLobby(LobbyInfo) )
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return LobbyInfo.Members.length;
|
|
}
|
|
}
|
|
|
|
|
|
function OnFindGameServerComplete(bool bWasSuccessful)
|
|
{
|
|
if (bWasSuccessful && !bPauseTryingServers)
|
|
{
|
|
// If doing takeover, randomize the list to reduce risk of clients trying to take over the same server. Order is irrelevant for console when (no ping)
|
|
if( bAttemptingServerCreate && (class'WorldInfo'.static.IsConsoleBuild() || class'WorldInfo'.static.IsEosBuild()) )
|
|
{
|
|
RandomizeSearchResults(SearchDataStore.GetActiveGameSearch());
|
|
}
|
|
// Regular join, sort normally
|
|
else if( class'WorldInfo'.static.IsConsoleBuild() || class'WorldInfo'.static.IsEosBuild() )
|
|
{
|
|
// Sort all entries for console
|
|
SortServers(SearchDataStore.GetActiveGameSearch());
|
|
}
|
|
else
|
|
{
|
|
SortLastEntry(SearchDataStore.GetActiveGameSearch());
|
|
}
|
|
}
|
|
TryNextServer();
|
|
}
|
|
|
|
native function bool SpaceAvailable(const OnlineGameSettings Settings);
|
|
native function bool MapGood(const OnlineGameSettings Settings, optional out string CurrentMap);
|
|
native function SortLastEntry(OnlineGameSearch Search);
|
|
native function SortServers(OnlineGameSearch Search);
|
|
native function RandomizeSearchResults(OnlineGameSearch Search);
|
|
|
|
function string BuildJoinFiltersRequestURL()
|
|
{
|
|
local string FiltersURL;
|
|
local int GameMode, GameDifficulty;
|
|
|
|
GameMode = Manager.GetModeIndex();
|
|
GameDifficulty = OptionsComponent.GetDifficulty();
|
|
|
|
if( GameMode >= 0 )
|
|
{
|
|
FiltersURL $= "?Game="$class'KFGameInfo'.static.GetGameModeClassFromNum(GameMode);
|
|
}
|
|
|
|
if( GameDifficulty >= 0)
|
|
{
|
|
FiltersURL $= "?Difficulty="$GameDifficulty;
|
|
}
|
|
|
|
if( OptionsComponent.bLengthFilterSet )
|
|
{
|
|
FiltersURL $= "?GameLength="$OptionsComponent.LengthFilter;
|
|
}
|
|
|
|
return FiltersURL;
|
|
}
|
|
|
|
function string BuildTakeoverURL(optional out string Password)
|
|
{
|
|
local string TakeoverURL;
|
|
|
|
TakeoverURL = MakeMapURL(OptionsComponent);
|
|
if (len(Password) > 0)
|
|
{
|
|
TakeoverURL $= "?gamepassword=" $ Password $ "?password=" $ Password;
|
|
}
|
|
|
|
// For console builds, if we're creating a private server, ensure private=1 is part of the takeover.
|
|
TakeoverURL $= "?Private="$OptionsComponent.GetPrivacyIndex();
|
|
if( class'WorldInfo'.static.IsConsoleBuild() && OptionsComponent.GetPrivacyIndex() == ESPr_PasswordProtected)
|
|
{
|
|
TakeoverURL $= "?bJoinViaInvite";
|
|
}
|
|
|
|
return TakeoverURL $ OnlineLobby.GetLobbyURLString();
|
|
}
|
|
|
|
private native function SecureTakeover(const out string Address, const string TakeoverURL);
|
|
|
|
function OnJoinGameComplete(name SessionName, bool bSuccessful)
|
|
{
|
|
if(GameInterface != none)
|
|
{
|
|
GameInterface.ClearJoinOnlineGameCompleteDelegate(OnJoinGameComplete);
|
|
}
|
|
|
|
if (!bSuccessful)
|
|
{
|
|
AttemptingJoin = false;
|
|
`log("KFGFxMenu_StartGame.OnJoinGameComplete: join online game failed completion for server index"@CurrentSearchIndex, bLogSearchInfo);
|
|
TryNextServer();
|
|
return;
|
|
}
|
|
if (GameInterface.GetResolvedConnectString(SessionName, PendingResolvedAddress))
|
|
{
|
|
`log("KFGFxMenu_StartGame.OnJoinGameComplete: OnJoinGameComplete called for server index"@CurrentSearchIndex, bLogSearchInfo);
|
|
KFGameEngine(Class'Engine'.static.GetEngine()).OnHandshakeComplete = OnHandshakeComplete;
|
|
SetServerConnectGiveUpTimer(OptionsComponent.GetMakeNewServer());
|
|
if (OptionsComponent.GetMakeNewServer())
|
|
{
|
|
`log("KFGFxMenu_StartGame.OnJoinGameComplete: servertakeover"@PendingResolvedAddress@BuildTakeoverURL(LobbyOwnerPassword), bLogSearchInfo);
|
|
SecureTakeover(PendingResolvedAddress, BuildTakeoverURL(LobbyOwnerPassword));
|
|
}
|
|
else
|
|
{
|
|
GetPC().ConsoleCommand("open"@PendingResolvedAddress$BuildJoinFiltersRequestURL()$OnlineLobby.GetLobbyURLString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AttemptingJoin = false;
|
|
`log("KFGFxMenu_StartGame.OnJoinGameComplete: unable to resolve server address, bLogSearchInfo");
|
|
TryNextServer();
|
|
}
|
|
}
|
|
|
|
|
|
function ConnectToPlayfabServer(string ServerIp)
|
|
{
|
|
local string OpenCommand;
|
|
local bool bInParty;
|
|
|
|
// First we need to know if we're joining or taking over
|
|
OpenCommand = bAttemptingServerCreate ? "servertakeover" : "open";
|
|
OpenCommand @= ServerIp;
|
|
|
|
bInParty = OnlineLobby != None && OnlineLobby.IsInLobby() && OnlineLobby.IsLobbyOwner();
|
|
|
|
if( bInParty )
|
|
{
|
|
PendingResolvedAddress = ServerIp;
|
|
}
|
|
|
|
if( bAttemptingServerCreate )
|
|
{
|
|
if ( class'WorldInfo'.static.IsEOSBuild() )
|
|
{
|
|
OpenCommand @= BuildTakeoverURL(LobbyOwnerPassword);
|
|
}
|
|
else
|
|
{
|
|
OpenCommand @= BuildTakeoverURL();
|
|
}
|
|
}
|
|
else if( bInParty )
|
|
{
|
|
OpenCommand $= OnlineLobby.GetLobbyURLString();
|
|
}
|
|
|
|
// Regular join
|
|
if( !bAttemptingServerCreate )
|
|
{
|
|
OpenCommand $= BuildJoinFiltersRequestURL();
|
|
}
|
|
|
|
KFGameEngine(Class'Engine'.static.GetEngine()).OnHandshakeComplete = OnHandshakeComplete;
|
|
// Give a longer timeout for servers that need to spin up
|
|
//@SABER_EGS_BEGIN fix connecting timeout via takeOver
|
|
//if (class'WorldInfo'.static.IsEosBuild())
|
|
//{
|
|
// SetServerConnectGiveUpTimer(bAttemptingServerCreate);
|
|
//}
|
|
//else
|
|
//{
|
|
`TimerHelper.SetTimer( bAttemptingServerCreate ? 8 : ServerConnectTimeout, false, nameof(ServerConnectGiveUp), self);
|
|
//}
|
|
//@SABER_EGS_END
|
|
|
|
// Attach playfab ID
|
|
OpenCommand $= "?PlayfabPlayerId="$class'GameEngine'.static.GetPlayfabInterface().CachedPlayfabId;
|
|
|
|
`log("Going to connect with URL:"@OpenCommand);
|
|
ConsoleCommand( OpenCommand );
|
|
}
|
|
|
|
|
|
|
|
event SetServerConnectGiveUpTimer(bool ServerTakover)
|
|
{
|
|
`TimerHelper.SetTimer(ServerTakover ? ServerTakeoverTimeout : ServerConnectTimeout, false, nameof(ServerConnectGiveUp), self);
|
|
}
|
|
|
|
event AddJoinGameCompleteDelegate(OnlineGameSearch LatestGameSearch)
|
|
{
|
|
if( (class'WorldInfo'.static.IsConsoleBuild() && !class'WorldInfo'.static.IsE3Build()) || class'WorldInfo'.static.IsEOSBuild() )
|
|
{
|
|
if( LatestGameSearch.Results[CurrentSearchIndex].GameSettings.JoinString == "" )
|
|
{
|
|
AttemptingJoin = false;
|
|
TryNextServer();
|
|
}
|
|
else
|
|
{
|
|
ConnectToPlayfabServer(LatestGameSearch.Results[CurrentSearchIndex].GameSettings.JoinString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GameInterface.AddJoinOnlineGameCompleteDelegate(OnJoinGameComplete);
|
|
GameInterface.JoinOnlineGame(0, 'Game', LatestGameSearch.Results[CurrentSearchIndex]);
|
|
}
|
|
}
|
|
|
|
function ServerConnectGiveUp()
|
|
{
|
|
`log("KFGFxMenu_StartGame.ServerConnectGiveUp: ServerConnectGiveUp", bLogSearchInfo);
|
|
KFGameEngine(Class'KFGameEngine'.static.GetEngine()).KillPendingServerConnection();
|
|
}
|
|
|
|
function OnOpen()
|
|
{
|
|
if( Manager != none )
|
|
{
|
|
Manager.SetStartMenuState(EStartMenuState(GetStartMenuState()));
|
|
}
|
|
if(MissionObjectiveContainer != none)
|
|
{
|
|
MissionObjectiveContainer.Refresh(true);
|
|
}
|
|
}
|
|
|
|
function OnServerTakeoverResponseRecieved()
|
|
{
|
|
`log(GetFuncName());
|
|
if( class'WorldInfo'.static.IsEosBuild() )
|
|
{
|
|
`TimerHelper.ClearTimer(nameof(ServerConnectGiveUp), self);
|
|
}
|
|
}
|
|
|
|
function bool OnHandshakeComplete(bool bSuccess, string Description, out int SuppressPasswordRetry)
|
|
{
|
|
`log("KFGFxMenu_StartGame.OnHandShakeComplete", bLogSearchInfo);
|
|
AttemptingJoin = false;
|
|
|
|
KFGameEngine(Class'Engine'.static.GetEngine()).OnHandshakeComplete = None;
|
|
`TimerHelper.ClearTimer(nameof(ServerConnectGiveUp), self);
|
|
if (bSuccess)
|
|
{
|
|
`log("KFGFxMenu_StartGame.OnHandShakeComplete: LobbyJoinServer" @ PendingResolvedAddress, bLogSearchInfo);
|
|
if( class'WorldInfo'.static.IsConsoleBuild() )
|
|
{
|
|
if(OnlineLobby != None && OnlineLobby.IsInLobby() && OnlineLobby.IsLobbyOwner())
|
|
{
|
|
OnlineLobby.LobbyJoinServer(PendingResolvedAddress);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Len(LobbyOwnerPassword) > 0)
|
|
{
|
|
OnlineLobby.SetServerPassword(LobbyOwnerPassword);
|
|
}
|
|
OnlineLobby.LobbyJoinServer(PendingResolvedAddress);
|
|
}
|
|
PendingResolvedAddress = "";
|
|
}
|
|
else
|
|
{
|
|
`log("KFGFxMenu_StartGame.OnHandShakeComplete: TryNextServer", bLogSearchInfo);
|
|
//@HSL_BEGIN - JRO - Console doesn't make a session until after connect, don't need to clean it up on failure. Also, Party is a session and that needs to *not* be destroyed!
|
|
if( !class'WorldInfo'.static.IsConsoleBuild() )
|
|
{
|
|
GameInterface.DestroyOnlineGame('Game');
|
|
}
|
|
//@HSL_END
|
|
PendingResolvedAddress = "";
|
|
TryNextServer();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
event OnClose()
|
|
{
|
|
if(OverviewContainer != none)
|
|
{
|
|
OverviewContainer.ActionScriptVoid("hideSharedContentList");
|
|
}
|
|
KFGameEngine(Class'Engine'.static.GetEngine()).OnHandshakeComplete = None;
|
|
if(GameInterface != none)
|
|
{
|
|
GameInterface.ClearFindOnlineGamesCompleteDelegate(OnFindGameServerComplete);
|
|
GameInterface.ClearJoinOnlineGameCompleteDelegate(OnJoinGameComplete);
|
|
}
|
|
|
|
Manager.CachedProfile.Save( GetLP().ControllerId );
|
|
|
|
if( (class'WorldInfo'.static.IsConsoleBuild() || class'WorldInfo'.static.IsEOSBuild()) && !class'WorldInfo'.static.IsE3Build() )
|
|
{
|
|
class'GameEngine'.static.GetPlayfabInterface().ClearFindOnlineGamesCompleteDelegate( OnFindGameServerComplete );
|
|
}
|
|
}
|
|
|
|
function AddLobbyFilter(out array<LobbyFilter> Filters, bool bIsSet, string Key, coerce String Val, bool bNumeric)
|
|
{
|
|
local LobbyFilter filter;
|
|
|
|
if ( bIsSet )
|
|
{
|
|
filter.Key = Key;
|
|
filter.Value = Val;
|
|
filter.Operator = OGSCT_Equals;
|
|
filter.bNumeric = bNumeric;
|
|
|
|
Filters.AddItem(filter);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************/
|
|
// Match Making
|
|
/********************************************************************************/
|
|
|
|
function BuildServerFilters(OnlineGameInterface GameInterfaceSteam, KFGFxStartGameContainer_Options Options, OnlineGameSearch Search)
|
|
{
|
|
local int GameMode;
|
|
local int GameDifficulty;
|
|
local int GameLength;
|
|
local string GameTagFilters;
|
|
local ActiveLobbyInfo LobbyInfo;
|
|
|
|
Search.ClearServerFilters();
|
|
|
|
// TODO: Eventually will want to support this. For now using PLAYFAB_BUILD_VERSION define
|
|
if( class'WorldInfo'.static.IsConsoleBuild() )
|
|
{
|
|
Search.AddGametagFilter(GameTagFilters, 'Region', class'GameEngine'.static.GetPlayfabInterface().CurrRegionName);
|
|
}
|
|
// Consoles MUST set region
|
|
else
|
|
{
|
|
Search.AddServerFilter("version_match", string(class'KFGameEngine'.static.GetKFGameVersion()));
|
|
}
|
|
|
|
if (OptionsComponent.GetMakeNewServer() || bAttemptingServerCreate )
|
|
{
|
|
Search.AddGametagFilter( GameTagFilters, 'bAvailableForTakeover', "1");
|
|
Search.AddGametagFilter( GameTagFilters, 'bRequiresPassword', "0");
|
|
}
|
|
else
|
|
{
|
|
if( OnlineLobby != none && OnlineLobby.GetCurrentLobby(LobbyInfo) && LobbyInfo.Members.length >= 6)
|
|
{
|
|
Search.AddServerFilter( "noplayers", "");
|
|
}
|
|
else
|
|
{
|
|
Search.AddServerFilter("notfull", "");
|
|
}
|
|
|
|
GameMode = Manager.GetModeIndex();
|
|
if( GameMode >= 0 )
|
|
{
|
|
Search.AddGametagFilter( GameTagFilters, 'Mode', string(GameMode) );
|
|
}
|
|
|
|
//For modes that don't use filtered difficulty, don't even attempt to send this (Ex: Weekly)
|
|
if (ShouldUseDifficultyFilter(GameMode))
|
|
{
|
|
GameDifficulty = OptionsComponent.GetDifficulty();
|
|
if (GameDifficulty >= 0)
|
|
{
|
|
Search.AddGametagFilter(GameTagFilters, 'Difficulty', string(GameDifficulty));
|
|
}
|
|
}
|
|
|
|
//For modes that don't use filtered length, don't even attempt to send this (Ex: Weekly)
|
|
if (ShouldUseLengthFilter(GameMode))
|
|
{
|
|
GameLength = OptionsComponent.GetGameLength();
|
|
if (GameLength >= 0)
|
|
{
|
|
Search.AddGametagFilter(GameTagFilters, 'NumWaves', string(GameLength));
|
|
}
|
|
}
|
|
|
|
Search.TestAddBoolGametagFilter(GameTagFilters, true, 'bRequiresPassword', 0);
|
|
Search.TestAddBoolGametagFilter(GameTagFilters, false, 'bInProgress', 0);
|
|
|
|
if (!class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
// aka server type "stock"
|
|
Search.TestAddBoolGametagFilter(GameTagFilters, true, 'bCustom', 0);
|
|
Search.TestAddBoolGametagFilter(GameTagFilters, true, 'bUsesStats', 1);
|
|
}
|
|
}
|
|
|
|
if (Len(GameTagFilters) > 0)
|
|
{
|
|
Search.AddServerFilter( "gametagsand", GameTagFilters);
|
|
}
|
|
if (Search.MasterServerSearchKeys.length > 1)
|
|
{
|
|
Search.AddServerFilter( "and", string(Search.MasterServerSearchKeys.length), 0);
|
|
}
|
|
}
|
|
|
|
function bool ShouldUseDifficultyFilter(int GameModeIndex)
|
|
{
|
|
switch (GameModeIndex)
|
|
{
|
|
//Weekly
|
|
case 1:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool ShouldUseLengthFilter(int GameModeIndex)
|
|
{
|
|
switch (GameModeIndex)
|
|
{
|
|
//Weekly
|
|
case 1:
|
|
//Endless
|
|
case 3:
|
|
// Objective Mode
|
|
case 4:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function Callback_StartGame()
|
|
{
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameString, Class'KFCommon_LocalizedStrings'.default.StartOfflineGameDescriptionString,
|
|
Class'KFCommon_LocalizedStrings'.default.DisbandPartyString,
|
|
Class'KFCommon_LocalizedStrings'.default.CancelString, Callback_StartOfflineGame); //middle button
|
|
}
|
|
else
|
|
{
|
|
Callback_StartOfflineGame();
|
|
}
|
|
|
|
}
|
|
|
|
function Callback_StartOfflineGame()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if (OnlineLobby != none && OnlineLobby.IsInLobby())
|
|
{
|
|
OnlineLobby.QuitLobby();
|
|
}
|
|
|
|
if (!OnlineSub.IsGameOwned() && class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Orbis))
|
|
{
|
|
if (OnlineSub.CanCheckFreeTrialState() && !OnlineSub.IsFreeTrialPeriodActive())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_BuyGame);
|
|
return;
|
|
}
|
|
|
|
if (!OnlineSub.CanCheckFreeTrialState())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_NetworkCheckFailed);
|
|
return;
|
|
}
|
|
}
|
|
ConsoleCommand("open" @ MakeMapURL(OptionsComponent));
|
|
}
|
|
|
|
event StartOnlineGame()
|
|
{
|
|
OptionsComponent.UpdateFilters();
|
|
/*
|
|
if (OptionsComponent.GetServerTypeListen())
|
|
{
|
|
//`log("******open" @ MakeMapURL(OptionsComponent)$"?listen?steamsockets");
|
|
ConsoleCommand("open" @ MakeMapURL(OptionsComponent)$"?listen?steamsockets");
|
|
OnlineLobby.LobbyJoinGame();
|
|
|
|
return;
|
|
}
|
|
*/
|
|
GameInterface.SetMatchmakingTypeMode(SMT_Internet);
|
|
|
|
CurrentSearchIndex = 0;
|
|
|
|
// If this is supposed to be a private game, it has to be a takeover
|
|
if( class'WorldInfo'.static.IsConsoleBuild() && OptionsComponent.GetPrivacyIndex() == 1 )
|
|
{
|
|
bAttemptingServerCreate = true;
|
|
}
|
|
|
|
BuildServerFilters(GameInterface, OptionsComponent, SearchDataStore.GetCurrentGameSearch());
|
|
SearchDataStore.GetCurrentGameSearch().MaxSearchResults = MaxResultsToTry;
|
|
|
|
if( (class'WorldInfo'.static.IsConsoleBuild() && !class'WorldInfo'.static.IsE3Build()) || class'WorldInfo'.static.IsEOSBuild() )
|
|
{
|
|
AttemptingJoin = false;
|
|
class'GameEngine'.static.GetPlayfabInterface().AddFindOnlineGamesCompleteDelegate( OnFindGameServerComplete );
|
|
}
|
|
else
|
|
{
|
|
// Add a delegate for when the search completes. We will use this callback to do any post searching work.
|
|
GameInterface.AddFindOnlineGamesCompleteDelegate(OnFindGameServerComplete);
|
|
}
|
|
|
|
if (class'WorldInfo'.static.IsEOSBuild())
|
|
{
|
|
SearchFinished = false;
|
|
}
|
|
|
|
// Start a search
|
|
if ( !SearchDataStore.SubmitGameSearch(class'UIInteraction'.static.GetPlayerControllerId(0), false) )
|
|
{
|
|
GameInterface.ClearFindOnlineGamesCompleteDelegate(OnFindGameServerComplete);
|
|
|
|
if( (class'WorldInfo'.static.IsConsoleBuild() && !class'WorldInfo'.static.IsE3Build()) || class'WorldInfo'.static.IsEOSBuild() )
|
|
{
|
|
// BWJ - Not clearing this delegate because sometimes you can run into instances where the search fails because one is already in progress.
|
|
// We do not want to clear the delegate when this happens. Players can end up in an "infinite search" because they never get the callback.
|
|
// class'GameEngine'.static.GetPlayfabInterface().ClearFindOnlineGamesCompleteDelegate( OnFindGameServerComplete );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bPauseTryingServers = true;
|
|
`TimerHelper.SetTimer(InitialSearchPause, false, nameof(UnpauseTryingServers), self);
|
|
bSearchingForGame = true;
|
|
|
|
OptionsComponent.SetSearching(bSearchingForGame);
|
|
}
|
|
}
|
|
|
|
function ShowServerTakeoverPasswordPrompt()
|
|
{
|
|
Manager.DelayedOpenPopup(EInputPrompt, EDPPID_Misc,class'KFCommon_LocalizedStrings'.default.SetTakeoverServerPasswordTitle, "" , class'KFCommon_LocalizedStrings'.default.ConfirmString, class'KFCommon_LocalizedStrings'.default.CancelString, OnSetTakoverServerPassword);
|
|
}
|
|
|
|
function OnSetTakoverServerPassword()
|
|
{
|
|
local string Password;
|
|
|
|
Password = KFGFxPopup_InputPrompt(Manager.CurrentPopup).PlayerInputString;
|
|
|
|
LobbyOwnerPassword = Password;
|
|
StartOnlineGame();
|
|
}
|
|
|
|
native function string GenerateRandomPassword();
|
|
|
|
function Callback_StartOnlineGame()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if (!OnlineSub.IsGameOwned() && class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Orbis))
|
|
{
|
|
if (OnlineSub.CanCheckFreeTrialState() && !OnlineSub.IsFreeTrialPeriodActive())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_BuyGame);
|
|
return;
|
|
}
|
|
|
|
if (!OnlineSub.CanCheckFreeTrialState())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_NetworkCheckFailed);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( class'KFGameEngine'.static.IsFreeConsolePlayOver() )
|
|
{
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, "",
|
|
class'KFCommon_LocalizedStrings'.default.FreeConsolePlayOverString,
|
|
class'KFCommon_LocalizedStrings'.default.BuyGameString,
|
|
class'KFCommon_LocalizedStrings'.default.OKString, OnBuyGamePressed);
|
|
return;
|
|
}
|
|
|
|
bAttemptingServerCreate = false;
|
|
StartOnlineGame();
|
|
}
|
|
|
|
function Callback_CreateOnlineGame()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
CancelGameSearch();
|
|
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
|
|
if (!OnlineSub.IsGameOwned() && class'WorldInfo'.static.IsConsoleBuild(CONSOLE_Orbis))
|
|
{
|
|
if (OnlineSub.CanCheckFreeTrialState() && !OnlineSub.IsFreeTrialPeriodActive())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_BuyGame);
|
|
return;
|
|
}
|
|
|
|
if (!OnlineSub.CanCheckFreeTrialState())
|
|
{
|
|
Manager.HandleFreeTrialError(FTN_NetworkCheckFailed);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (class'KFGameEngine'.static.IsFreeConsolePlayOver())
|
|
{
|
|
Manager.DelayedOpenPopup(EConfirmation, EDPPID_Misc, "",
|
|
class'KFCommon_LocalizedStrings'.default.FreeConsolePlayOverString,
|
|
class'KFCommon_LocalizedStrings'.default.BuyGameString,
|
|
class'KFCommon_LocalizedStrings'.default.OKString, OnBuyGamePressed);
|
|
return;
|
|
}
|
|
|
|
LobbyOwnerPassword = "";
|
|
bAttemptingServerCreate = true;
|
|
if (OptionsComponent.GetPrivacyIndex() == ESPr_PasswordProtected && !class'WorldInfo'.static.IsConsoleBuild())
|
|
{
|
|
ShowServerTakeoverPasswordPrompt();
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
StartOnlineGame();
|
|
}
|
|
}
|
|
|
|
/** Called when player selects buy game from the end of demo popup */
|
|
function OnBuyGamePressed()
|
|
{
|
|
local OnlineSubsystem OnlineSub;
|
|
|
|
if( class'WorldInfo'.static.IsConsoleBuild( CONSOLE_Orbis ) )
|
|
{
|
|
OnlineSub = Class'GameEngine'.static.GetOnlineSubsystem();
|
|
OnlineSub.OpenGameStorePage();
|
|
}
|
|
}
|
|
|
|
function UnpauseTryingServers()
|
|
{
|
|
bPauseTryingServers = false;
|
|
if( bAttemptingServerCreate )
|
|
{
|
|
RandomizeSearchResults(SearchDataStore.GetActiveGameSearch());
|
|
}
|
|
else
|
|
{
|
|
SortServers(SearchDataStore.GetActiveGameSearch());
|
|
}
|
|
|
|
TryNextServer();
|
|
}
|
|
|
|
event CancelGameSearch()
|
|
{
|
|
local KFOnlineGameSearch ActiveGameSearch;
|
|
ActiveGameSearch = KFOnlineGameSearch(SearchDataStore.GetActiveGameSearch());
|
|
|
|
if(ActiveGameSearch != none)
|
|
{
|
|
if( (class'WorldInfo'.static.IsConsoleBuild() || class'WorldInfo'.static.IsEOSBuild()) && !class'WorldInfo'.static.IsE3Build() )
|
|
{
|
|
class'GameEngine'.static.GetPlayfabInterface().CancelGameSearch();
|
|
OnCancelSearchComplete(true);
|
|
}
|
|
else
|
|
{
|
|
GameInterface.AddCancelFindOnlineGamesCompleteDelegate(OnCancelSearchComplete);
|
|
GameInterface.CancelFindOnlineGames();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnCancelSearchComplete(false);
|
|
}
|
|
OptionsComponent.SetHelpText("");
|
|
}
|
|
|
|
function OnCancelSearchComplete(bool bWasSuccessful)
|
|
{
|
|
bSearchingForGame = false;
|
|
OptionsComponent.SetSearching(bSearchingForGame);
|
|
Manager.SetSearchingForMatch(bSearchingForGame);
|
|
}
|
|
|
|
event int GetGameModeIndex()
|
|
{
|
|
local KFGameReplicationInfo KFGRI;
|
|
KFGRI = KFGameReplicationInfo(class'WorldInfo'.static.GetWorldInfo().GRI);
|
|
|
|
if(Manager != none)
|
|
{
|
|
return Manager.GetModeIndex();
|
|
}
|
|
else if (KFGRI != none)
|
|
{
|
|
return class'KFGameInfo'.static.GetGameModeIndexFromName(string(KFGRI.GameClass.name));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/********************************************************************************/
|
|
// End Match Making
|
|
/********************************************************************************/
|
|
|
|
function ShowOverview( bool bShowOverview, bool bLeader, bool bInMainMenu, bool bhostInServerBrowser)
|
|
{
|
|
if (bShowOverview)
|
|
{
|
|
if (bInMainMenu)
|
|
{
|
|
if (!bLeader)
|
|
{
|
|
if (bhostInServerBrowser)
|
|
{
|
|
SetInt("externalMenuState", EServerBrowserOverview);
|
|
}
|
|
else
|
|
{
|
|
SetInt("externalMenuState", EOverview);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetInt("externalMenuState", EOverview);
|
|
}
|
|
}
|
|
}
|
|
|
|
function OnPartyLeave()
|
|
{
|
|
SetInt("externalMenuState", EStartHome);
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
ModeKey="ModeKey"
|
|
DifficultyKey="DifficultyKey"
|
|
MapKey="MapKey"
|
|
GameLengthKey="GameLengthKey"
|
|
WhitelistedKey="WhitelistedKey"
|
|
ServerTypeKey="ServerTypeKey"
|
|
InProgressKey="InProgress"
|
|
PermissionsKey="PermissionsKey"
|
|
SearchDSName=KFGameSearch
|
|
|
|
CurrentSearchIndex=0
|
|
|
|
bIsLeader = false
|
|
bIsInParty = false
|
|
|
|
SubWidgetBindings.Add((WidgetName="findGameContainer",WidgetClass=class'KFGFxStartGameContainer_FindGame'))
|
|
SubWidgetBindings.Add((WidgetName="serverBrowserOverviewContainer",WidgetClass=class'KFGFxStartContainer_ServerBrowserOverview'))
|
|
SubWidgetBindings.Add((WidgetName="gameOptionsContainer",WidgetClass=class'KFGFxStartGameContainer_Options'))
|
|
SubWidgetBindings.Add((WidgetName="overviewContainer",WidgetClass=class'KFGFxStartContainer_InGameOverview'))
|
|
SubWidgetBindings.Add((WidgetName="dailyContainerMC",WidgetClass=class'KFGFxDailyObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName="weeklyContainerMC",WidgetClass=class'KFGFxWeeklyObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName="missionObjectivesContainerMC",WidgetClass=class'KFGFxMissionObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName="collapsedMissionObjectivesMC",WidgetClass=class'KFGFxCollapsedObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName="specialEventContainerMC",WidgetClass=class'KFGFxSpecialeventObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName="expandedMissionObjectivesMC",WidgetClass=class'KFGFxExpandedObjectivesContainer'))
|
|
SubWidgetBindings.Add((WidgetName ="newsPage",WidgetClass=class'KFGFxStartContainer_NewsImageHolder'))
|
|
|
|
|
|
WhatsNewPS="http://www.killingfloor2.com/psnews"
|
|
WhatsNewMS="http://www.killingfloor2.com/xboxnews"
|
|
WhatsNewSteam="http://www.killingfloor2.com/pcnews"
|
|
}
|
|
|
|
|
|
|