Updated Quest Log Widgets and Quest base Actor (again)

I have updated the widgets and quest base actor to read updated objective progress and check or uncheck the quest log check box if the objective has been completed or not (I followed the tutorial the exact same and done nothing different so if it works idk why if not im pissed)

Config/DefaultEngine.ini

@@ -4,15 +4,17 @@
 +EditProfiles=(Name="Trigger",CustomResponses=((Channel=Projectile, Response=ECR_Ignore)))
 
 [/Script/EngineSettings.GameMapsSettings]
-EditorStartupMap=/Game/FirstPerson/Maps/FirstPersonMap.FirstPersonMap
+EditorStartupMap=/Game/MainMenu/MAP_MainMenu.MAP_MainMenu
 LocalMapOptions=
-TransitionMap=
+TransitionMap=None
 bUseSplitscreen=True
 TwoPlayerSplitscreenLayout=Horizontal
 ThreePlayerSplitscreenLayout=FavorTop
-GameInstanceClass=/Script/Engine.GameInstance
+FourPlayerSplitscreenLayout=Grid
-GameDefaultMap=/Game/FirstPerson/Maps/FirstPersonMap.FirstPersonMap
+bOffsetPlayerGamepadIds=False
-ServerDefaultMap=/Engine/Maps/Entry
+GameInstanceClass=/Game/Blueprints/GI_Monolith.GI_Monolith_C
+GameDefaultMap=/Game/MainMenu/MAP_MainMenu.MAP_MainMenu
+ServerDefaultMap=/Engine/Maps/Entry.Entry
 GlobalDefaultGameMode=/Game/FirstPerson/Blueprints/BP_FirstPersonGameMode.BP_FirstPersonGameMode_C
 GlobalDefaultServerGameMode=None
 
@@ -93,3 +95,22 @@ ConnectionType=USBOnly
 bUseManualIPAddress=False
 ManualIPAddress=
 
+[/Script/Engine.GameEngine]
++NetDriverDefinitions=(DefName="GameNetDriver",DriverClassName="OnlineSubsystemSteam.SteamNetDriver",DriverClassNameFallback="OnlineSubsystemUtils.IpNetDriver")
+
+[OnlineSubsystem]
+DefaultPlatformService=Steam
+
+[OnlineSubsystemSteam]
+bEnabled=true
+SteamDevAppId=480
+
+; If using Sessions
+bInitServerOnClient=true
+
+[/Script/OnlineSubsystemSteam.SteamNetDriver]
+NetConnectionClassName="OnlineSubsystemSteam.SteamNetConnection"
+
+[/Script/Engine.UserInterfaceSettings]
+UIScaleCurve=(EditorCurveData=(Keys=((Time=480.000000,Value=0.444000),(Time=720.000000,Value=0.666000),(Time=1080.000000,Value=1.000000),(Time=8640.000000,Value=2.500000)),DefaultValue=340282346638528859811704183484516925440.000000,PreInfinityExtrap=RCCE_Constant,PostInfinityExtrap=RCCE_Constant),ExternalCurve=None)
+

Config/DefaultInput.ini

@@ -92,7 +92,9 @@ bCaptureMouseOnLaunch=True
 bEnableLegacyInputScales=True
 bEnableMotionControls=True
 bFilterInputByPlatformUser=False
+bEnableInputDeviceSubsystem=True
 bShouldFlushPressedKeysOnViewportFocusLost=True
+bEnableDynamicComponentInputBinding=True
 bAlwaysShowTouchInterface=False
 bShowConsoleOnFourFingerTap=True
 bEnableGestureRecognizer=False
@@ -101,6 +103,19 @@ DefaultViewportMouseCaptureMode=CapturePermanently_IncludingInitialMouseDown
 DefaultViewportMouseLockMode=LockOnCapture
 FOVScale=0.011110
 DoubleClickTime=0.200000
++ActionMappings=(ActionName="Jump",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=SpaceBar)
++ActionMappings=(ActionName="Crouch",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=LeftControl)
++ActionMappings=(ActionName="Sprint",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=LeftShift)
++ActionMappings=(ActionName="Use Left Weapon",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=LeftMouseButton)
++ActionMappings=(ActionName="Use Right Weapon",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=RightMouseButton)
++ActionMappings=(ActionName="Ability1",bShift=False,bCtrl=False,bAlt=True,bCmd=False,Key=One)
++ActionMappings=(ActionName="Interact",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=E)
++AxisMappings=(AxisName="MoveForward",Scale=1.000000,Key=W)
++AxisMappings=(AxisName="MoveForward",Scale=-1.000000,Key=S)
++AxisMappings=(AxisName="MoveRight",Scale=1.000000,Key=D)
++AxisMappings=(AxisName="MoveRight",Scale=-1.000000,Key=A)
++AxisMappings=(AxisName="Turn",Scale=1.000000,Key=MouseX)
++AxisMappings=(AxisName="LookUp",Scale=-1.000000,Key=MouseY)
 DefaultPlayerInputClass=/Script/EnhancedInput.EnhancedPlayerInput
 DefaultInputComponentClass=/Script/EnhancedInput.EnhancedInputComponent
 DefaultTouchInterface=/Game/FirstPerson/Input/MobileControls.MobileControls

Monolith.uproject

@@ -7,7 +7,10 @@
 		{
 			"Name": "Monolith",
 			"Type": "Runtime",
-			"LoadingPhase": "Default"
+			"LoadingPhase": "Default",
+			"AdditionalDependencies": [
+				"Engine"
+			]
 		}
 	],
 	"Plugins": [
@@ -17,6 +20,52 @@
 			"TargetAllowList": [
 				"Editor"
 			]
+		},
+		{
+			"Name": "WorldPartitionHLODUtilities",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineSubsystemSteam",
+			"Enabled": true
+		},
+		{
+			"Name": "SteamSockets",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineSubsystemGooglePlay",
+			"Enabled": false,
+			"SupportedTargetPlatforms": [
+				"Android"
+			]
+		},
+		{
+			"Name": "OnlineSubsystemIOS",
+			"Enabled": false,
+			"SupportedTargetPlatforms": [
+				"IOS",
+				"TVOS"
+			]
+		},
+		{
+			"Name": "OnlineSubsystemNull",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineFramework",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineServicesNull",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineServicesOSSAdapter",
+			"Enabled": true
 		}
+	],
+	"TargetPlatforms": [
+		"Windows"
 	]
 }

Plugins/AdvancedSessions/AdvancedSessions.uplugin

@@ -0,0 +1,34 @@
+{
+	"FileVersion": 3,
+	"FriendlyName": "Advanced Sessions",
+	"Version": 5.4,
+	"VersionName": "5.4",
+	"Description": "Adds new blueprint functions to handle more advanced session operations.",
+	"Category": "Advanced Sessions Plugin",
+	"CreatedBy": "Joshua Statzer",
+	"CreatedByURL": "N/A",
+	"Modules": [
+		{
+			"Name": "AdvancedSessions",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault"
+		}
+	],
+	"Plugins": [
+		{
+			"Name": "OnlineSubsystem",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineSubsystemUtils",
+			"Enabled": true
+		}
+	],
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"SupportURL": "",
+	"CanContainContent": false,
+	"IsBetaVersion": false,
+	"IsExperimentalVersion": false,
+	"Installed": false
+}

Plugins/AdvancedSessions/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

Plugins/AdvancedSessions/Source/AdvancedSessions/AdvancedSessions.Build.cs

@@ -0,0 +1,17 @@
+using UnrealBuildTool;
+using System.IO;
+ 
+public class AdvancedSessions : ModuleRules
+{
+    public AdvancedSessions(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        //bEnforceIWYU = true;
+
+        PublicDefinitions.Add("WITH_ADVANCED_SESSIONS=1");
+
+       // PrivateIncludePaths.AddRange(new string[] { "AdvancedSessions/Private"/*, "OnlineSubsystemSteam/Private"*/ });
+       // PublicIncludePaths.AddRange(new string[] { "AdvancedSessions/Public" });
+        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "OnlineSubsystem", "CoreUObject", "OnlineSubsystemUtils", "Networking", "Sockets"/*"Voice", "OnlineSubsystemSteam"*/ });
+    }
+}

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedExternalUILibrary.h

@@ -0,0 +1,63 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "Engine/LocalPlayer.h"
+#include "OnlineSubsystem.h"
+#include "BlueprintDataDefinitions.h"
+//#include "OnlineFriendsInterface.h"
+//#include "OnlineUserInterface.h"
+//#include "OnlineMessageInterface.h"
+//#include "OnlinePresenceInterface.h"
+//#include "Engine/GameInstance.h"
+#include "Interfaces/OnlineSessionInterface.h"
+
+//#include "UObjectIterator.h"
+
+#include "AdvancedExternalUILibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedExternalUILog, Log, All);
+
+UCLASS()
+class UAdvancedExternalUILibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	
+	//********* External UI Functions *************//
+
+	// Show the UI that handles the Friends list
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void ShowFriendsUI(UObject* WorldContextObject, APlayerController *PlayerController, EBlueprintResultSwitch &Result);
+
+	// Show the UI that handles inviting people to your game
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void ShowInviteUI(UObject* WorldContextObject, APlayerController *PlayerController, EBlueprintResultSwitch &Result);
+
+	// Show the UI that shows the leaderboard (doesn't work with steam)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void ShowLeaderBoardUI(UObject* WorldContextObject, FString LeaderboardName, EBlueprintResultSwitch &Result);
+
+	// Show the UI that shows a web URL
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", AutoCreateRefTerm = "AllowedDomains", WorldContext = "WorldContextObject"))
+	static void ShowWebURLUI(UObject* WorldContextObject, FString URLToShow, EBlueprintResultSwitch &Result, TArray<FString>& AllowedDomains, bool bEmbedded = false , bool bShowBackground = false, bool bShowCloseButton = false, int32 OffsetX = 0, int32 OffsetY = 0, int32 SizeX = 0, int32 SizeY = 0);
+
+	// Show the UI that shows a web URL
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (WorldContext = "WorldContextObject"))
+	static void CloseWebURLUI(UObject* WorldContextObject);
+
+
+	// Show the UI that shows the profile of a uniquenetid
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void ShowProfileUI(UObject* WorldContextObject, const FBPUniqueNetId PlayerViewingProfile, const FBPUniqueNetId PlayerToViewProfileOf, EBlueprintResultSwitch &Result);
+
+	// Show the UI that shows the account upgrade UI (doesn't work with steam)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedExternalUI", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void ShowAccountUpgradeUI(UObject* WorldContextObject, const FBPUniqueNetId PlayerRequestingAccountUpgradeUI, EBlueprintResultSwitch &Result);
+
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedFriendsGameInstance.h

@@ -0,0 +1,145 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineFriendsInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlineMessageInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Engine/LocalPlayer.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "OnlineSessionSettings.h"
+#include "UObject/UObjectIterator.h"
+#include "AdvancedFriendsInterface.h"
+
+#include "AdvancedFriendsGameInstance.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedFriendsInterfaceLog, Log, All);
+
+UCLASS()
+class ADVANCEDSESSIONS_API UAdvancedFriendsGameInstance : public UGameInstance
+{
+	GENERATED_BODY()
+public:
+
+	UAdvancedFriendsGameInstance(const FObjectInitializer& ObjectInitializer);
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AdvancedFriendsInterface)
+	bool bCallFriendInterfaceEventsOnPlayerControllers;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AdvancedFriendsInterface)
+	bool bCallIdentityInterfaceEventsOnPlayerControllers;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AdvancedFriendsInterface)
+	bool bCallVoiceInterfaceEventsOnPlayerControllers;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = AdvancedVoiceInterface)
+	bool bEnableTalkingStatusDelegate;
+
+	//virtual void PostLoad() override;
+	virtual void Shutdown() override;
+	virtual void Init() override;
+
+	//*** Session invite received by local ***//
+	FOnSessionInviteReceivedDelegate SessionInviteReceivedDelegate;
+	FDelegateHandle SessionInviteReceivedDelegateHandle;
+
+	//const FUniqueNetId& /*UserId*/, const FUniqueNetId& /*FromId*/, const FString& /*AppId*/, const FOnlineSessionSearchResult& /*InviteResult*/
+	void OnSessionInviteReceivedMaster(const FUniqueNetId & PersonInvited, const FUniqueNetId & PersonInviting, const FString & AppId, const FOnlineSessionSearchResult& SessionToJoin);
+
+	// After a session invite has been accepted by the local player this event is triggered, call JoinSession on the session result to join it
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnSessionInviteReceived(int32 LocalPlayerNum, FBPUniqueNetId PersonInviting, const FString& AppId, const FBlueprintSessionResult& SessionToJoin);
+
+	//*** Session invite accepted by local ***//
+	FOnSessionUserInviteAcceptedDelegate SessionInviteAcceptedDelegate;
+	FDelegateHandle SessionInviteAcceptedDelegateHandle;
+
+	void OnSessionInviteAcceptedMaster(const bool bWasSuccessful, int32 LocalPlayer, TSharedPtr<const FUniqueNetId> PersonInviting, const FOnlineSessionSearchResult& SessionToJoin);
+
+	// After a session invite has been accepted by the local player this event is triggered, call JoinSession on the session result to join it
+	// This function is currently not hooked up in any of Epics default subsystems, it is here for custom subsystems
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnSessionInviteAccepted(int32 LocalPlayerNum, FBPUniqueNetId PersonInvited, const FBlueprintSessionResult& SessionToJoin);
+
+
+	// After a voice status has changed this event is triggered if the bEnableTalkingStatusDelegate property is true
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedVoice")
+	void OnPlayerTalkingStateChanged(FBPUniqueNetId PlayerId, bool bIsTalking);
+
+	void OnPlayerTalkingStateChangedMaster(TSharedRef<const FUniqueNetId> PlayerId, bool bIsTalking);
+
+	FOnPlayerTalkingStateChangedDelegate PlayerTalkingStateChangedDelegate;
+	FDelegateHandle PlayerTalkingStateChangedDelegateHandle;
+
+
+	// Called when the designated LocalUser has changed login state
+	UFUNCTION(BlueprintImplementableEvent , Category = "AdvancedIdentity", meta = (DisplayName = "OnPlayerLoginChanged"))
+	void OnPlayerLoginChanged(int32 PlayerNum);
+
+	void OnPlayerLoginChangedMaster(int32 PlayerNum);
+	FOnLoginChangedDelegate PlayerLoginChangedDelegate;
+	FDelegateHandle PlayerLoginChangedDelegateHandle;
+
+	// Called when the designated LocalUser has changed login status
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedIdentity", meta = (DisplayName = "OnPlayerLoginStatusChanged"))
+	void OnPlayerLoginStatusChanged(int32 PlayerNum, EBPLoginStatus PreviousStatus, EBPLoginStatus NewStatus, FBPUniqueNetId NewPlayerUniqueNetID);
+
+	void OnPlayerLoginStatusChangedMaster(int32 PlayerNum, ELoginStatus::Type PreviousStatus, ELoginStatus::Type NewStatus, const FUniqueNetId & NewPlayerUniqueNetID);
+	FOnLoginStatusChangedDelegate PlayerLoginStatusChangedDelegate;
+	FDelegateHandle PlayerLoginStatusChangedDelegateHandle;
+
+
+	//*** Session Invite Received From Friend ***//
+	// REMOVED BECAUSE IT NEVER GETS CALLED
+	/*FOnSessionInviteReceivedDelegate SessionInviteReceivedDelegate;
+	FDelegateHandle SessionInviteReceivedDelegateHandle;
+
+	void OnSessionInviteReceivedMaster(const FUniqueNetId &InvitedPlayer, const FUniqueNetId &FriendInviting, const FOnlineSessionSearchResult& Session);
+
+	// After a session invite has been sent from a friend this event is triggered, call JoinSession on the session result to join it
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnSessionInviteReceived(const FBPUniqueNetId &InvitedPlayer, const FBPUniqueNetId &FriendInviting, const FBlueprintSessionResult &Session);
+	*/
+
+	//*** Friend Invite Accepted ***//
+	/*FOnInviteAcceptedDelegate FriendInviteAcceptedDelegate;
+	FDelegateHandle FriendInviteAcceptedDelegateHandle;
+
+	void OnFriendInviteAcceptedDelegateMaster(const FUniqueNetId& LocalPlayer, const FUniqueNetId &PlayerInvited);
+
+	// After a session invite has been accepted by a friend this event is triggered
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnFriendInviteAccepted(const FBPUniqueNetId &InvitedPlayer, const FBPUniqueNetId &PlayerInvited);
+	*/
+
+	//*** Friend Invite Rejected ***//
+	/*FOnInviteRejectedDelegate SessionInviteRejectedByFriendDelegate;
+	FDelegateHandle InviteRejectedByFriendDelegateHandle;
+
+	void OnFriendInviteRejectedDelegateMaster(const FUniqueNetId& LocalPlayer, const FUniqueNetId &PlayerDeclined);
+
+	// After a friend invite has been rejected this event is triggered
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnFriendInviteRejected(const FBPUniqueNetId &InvitedPlayer, const FBPUniqueNetId &PlayerDeclined);
+	*/
+
+	//*** Removed By Friend ***//
+	/*FOnFriendRemovedDelegate RemovedByFriendDelegate;
+	FDelegateHandle RemovedByFriendDelegateHandle;
+
+	void OnRemovedByFriendDelegateMaster(const FUniqueNetId& LocalPlayer, const FUniqueNetId &FriendRemoved);
+
+	// After a friend removed the player this event is triggered
+	UFUNCTION(BlueprintImplementableEvent, Category = "AdvancedFriends")
+	void OnRemovedByFriend(const FBPUniqueNetId &InvitedPlayer, const FBPUniqueNetId &FriendRemoved);*/
+};
+

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedFriendsInterface.h

@@ -0,0 +1,56 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineFriendsInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlineMessageInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "OnlineSessionSettings.h"
+#include "UObject/UObjectIterator.h"
+#include "BlueprintDataDefinitions.h"
+#include "AdvancedFriendsInterface.generated.h"
+
+
+UINTERFACE(MinimalAPI)
+class UAdvancedFriendsInterface : public UInterface
+{
+	GENERATED_UINTERFACE_BODY()
+};
+
+class IAdvancedFriendsInterface
+{
+	GENERATED_IINTERFACE_BODY()
+public:
+	
+	// Called when the designated LocalUser has accepted a session invite, use JoinSession on result to connect
+	UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "OnSessionInviteReceived"))
+	void OnSessionInviteReceived(FBPUniqueNetId PersonInviting, const FBlueprintSessionResult& SearchResult);
+
+	// Called when the designated LocalUser has accepted a session invite, use JoinSession on result to connect
+	UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "OnSessionInviteAccepted"))
+	void OnSessionInviteAccepted(FBPUniqueNetId PersonInvited, const FBlueprintSessionResult& SearchResult);
+
+	// Called when the designated LocalUser has accepted a session invite, use JoinSession on result to connect
+	UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "OnPlayerVoiceStateChanged"))
+	void OnPlayerVoiceStateChanged(FBPUniqueNetId PlayerId, bool bIsTalking);
+
+	// Called when the designated LocalUser has changed login state
+	UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "OnPlayerLoginChanged"))
+	void OnPlayerLoginChanged(int32 PlayerNum);
+
+	// Called when the designated LocalUser has changed login state
+	UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "OnPlayerLoginStatusChanged"))
+	void OnPlayerLoginStatusChanged(EBPLoginStatus PreviousStatus, EBPLoginStatus NewStatus, FBPUniqueNetId PlayerUniqueNetID);
+
+	// REMOVED BECAUSE IT WAS NEVER BEING CALLED
+	// Called when the designated LocalUser has received a session invite, use JoinSession on result to connect
+	//UFUNCTION(BlueprintImplementableEvent, meta = (FriendlyName = "OnSessionInviteReceived"))
+	//void OnSessionInviteReceived(const FBPUniqueNetId &FriendInviting, const FBlueprintSessionResult &Session);
+
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedFriendsLibrary.h

@@ -0,0 +1,56 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "Engine/LocalPlayer.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineFriendsInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlineMessageInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Interfaces/OnlineSessionInterface.h"
+
+#include "UObject/UObjectIterator.h"
+
+#include "AdvancedFriendsLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedFriendsLog, Log, All);
+
+UCLASS()
+class UAdvancedFriendsLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	
+	//********* Friend List Functions *************//
+
+	// Sends an Invite to the current online session to a list of friends
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|FriendsList", meta = (ExpandEnumAsExecs = "Result"))
+	static void SendSessionInviteToFriends(APlayerController *PlayerController, const TArray<FBPUniqueNetId> &Friends, EBlueprintResultSwitch &Result);
+
+	// Sends an Invite to the current online session to a friend
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|FriendsList", meta = (ExpandEnumAsExecs = "Result"))
+	static void SendSessionInviteToFriend(APlayerController *PlayerController, const FBPUniqueNetId &FriendUniqueNetId, EBlueprintResultSwitch &Result);
+
+	// Get a friend from the previously read/saved friends list (Must Call GetFriends first for this to return anything)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|FriendsList")
+	static void GetFriend(APlayerController *PlayerController, const FBPUniqueNetId FriendUniqueNetId, FBPFriendInfo &Friend);
+
+	// Get the previously read/saved friends list (Must Call GetFriends first for this to return anything)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|FriendsList")
+	static void GetStoredFriendsList(APlayerController *PlayerController, TArray<FBPFriendInfo> &FriendsList);
+
+	// Get the previously read/saved recent players list (Must Call GetRecentPlayers first for this to return anything)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|RecentPlayersList")
+	static void GetStoredRecentPlayersList(FBPUniqueNetId UniqueNetId, TArray<FBPOnlineRecentPlayer> &PlayersList);
+
+	// Check if a UniqueNetId is a friend
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedFriends|FriendsList")
+	static void IsAFriend(APlayerController *PlayerController, const FBPUniqueNetId UniqueNetId, bool &IsFriend);
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedGameSession.h

@@ -0,0 +1,71 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Engine/GameInstance.h"
+#include "GameFramework/GameModeBase.h"
+#include "GameFramework/GameSession.h"
+#include "GameFramework/PlayerState.h"
+
+//#include "UObjectIterator.h"
+
+#include "AdvancedGameSession.generated.h"
+
+
+
+
+/**
+ A quick wrapper around the game session to add a partial ban implementation. Just bans for the duration of the current session
+*/
+UCLASS(config = Game, notplaceable)
+class AAdvancedGameSession : public AGameSession
+{
+	GENERATED_UCLASS_BODY()
+
+public:
+
+	UPROPERTY(Transient)
+	TMap<FUniqueNetIdRepl, FText> BanList;
+
+	virtual bool BanPlayer(class APlayerController* BannedPlayer, const FText& BanReason)
+	{
+
+		if (APlayerState* PlayerState = (BannedPlayer != NULL) ? BannedPlayer->PlayerState : NULL)
+		{
+			FUniqueNetIdRepl UniqueNetID = PlayerState->GetUniqueId();
+			bool bWasKicked = KickPlayer(BannedPlayer, BanReason);
+
+			if (bWasKicked)
+			{
+				BanList.Add(UniqueNetID, BanReason);
+			}
+
+			return bWasKicked;
+		}
+		
+		return false;
+	}
+
+	// This should really be handled in the game mode asking game session, but I didn't want to force a custom game session AND game mode
+	// If done in the game mode, we could check prior to actually spooling up any player information in ApproveLogin
+	virtual void PostLogin(APlayerController* NewPlayer) override
+	{
+		if (APlayerState* PlayerState = (NewPlayer != NULL) ? NewPlayer->PlayerState : NULL)
+		{
+			FUniqueNetIdRepl UniqueNetID = PlayerState->GetUniqueId();
+
+			if (BanList.Contains(UniqueNetID))
+			{
+				KickPlayer(NewPlayer, BanList[UniqueNetID]);
+			}
+		}
+	}
+};
+
+AAdvancedGameSession::AAdvancedGameSession(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedIdentityLibrary.h

@@ -0,0 +1,81 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineIdentityInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Engine/LocalPlayer.h"
+
+#include "UObject/UObjectIterator.h"
+
+#include "AdvancedIdentityLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedIdentityLog, Log, All);
+
+UCLASS()
+class UAdvancedIdentityLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	//********* Identity Functions *************//
+
+	// Get the login status of a local player
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void GetLoginStatus(UObject* WorldContextObject, const FBPUniqueNetId & UniqueNetID, EBPLoginStatus & LoginStatus, EBlueprintResultSwitch &Result);
+
+	// Get the auth token for a local player
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void GetPlayerAuthToken(UObject* WorldContextObject, APlayerController * PlayerController, FString & AuthToken, EBlueprintResultSwitch &Result);
+
+	// Get a players nickname
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedIdentity", meta = (WorldContext = "WorldContextObject"))
+	static void GetPlayerNickname(UObject* WorldContextObject, const FBPUniqueNetId & UniqueNetID, FString & PlayerNickname);
+
+	//********* User Account Functions *************//
+
+	// Get a users account
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity|UserAccount", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void GetUserAccount(UObject* WorldContextObject, const FBPUniqueNetId & UniqueNetId, FBPUserOnlineAccount & AccountInfo, EBlueprintResultSwitch &Result);
+
+	// Get all known users accounts
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity|UserAccount", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+	static void GetAllUserAccounts(UObject* WorldContextObject, TArray<FBPUserOnlineAccount> & AccountInfos, EBlueprintResultSwitch &Result);
+
+	// Get a user account access token
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedIdentity|UserAccount")
+	static void GetUserAccountAccessToken(const FBPUserOnlineAccount & AccountInfo, FString & AccessToken);
+
+	// Get a user account Auth attribute (depends on subsystem)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity|UserAccount", meta = (ExpandEnumAsExecs = "Result"))
+	static void GetUserAccountAuthAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, FString & AuthAttribute, EBlueprintResultSwitch &Result);
+
+	// Set a user account attribute (depends on subsystem)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity|UserAccount", meta = (ExpandEnumAsExecs = "Result"))
+	static void SetUserAccountAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, const FString & NewAttributeValue, EBlueprintResultSwitch &Result);
+
+	// Get user ID
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedIdentity|UserAccount")
+	static void GetUserID(const FBPUserOnlineAccount & AccountInfo, FBPUniqueNetId & UniqueNetID);
+
+	// Get user accounts real name if possible
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedIdentity|UserAccount")
+	static void GetUserAccountRealName(const FBPUserOnlineAccount & AccountInfo, FString & UserName);
+
+	// Get user account display name if possible
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedIdentity|UserAccount")
+	static void GetUserAccountDisplayName(const FBPUserOnlineAccount & AccountInfo, FString & DisplayName);
+
+	// Get user account attribute (depends on subsystem)
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedIdentity|UserAccount", meta = (ExpandEnumAsExecs = "Result"))
+	static void GetUserAccountAttribute(const FBPUserOnlineAccount & AccountInfo, const FString & AttributeName, FString & AttributeValue, EBlueprintResultSwitch &Result);
+
+
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedSessions.h

@@ -0,0 +1,11 @@
+#pragma once
+ 
+#include "Modules/ModuleManager.h"
+
+class AdvancedSessions : public IModuleInterface
+{
+public:
+	/** IModuleInterface implementation */
+	void StartupModule();
+	void ShutdownModule();
+};

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedSessionsLibrary.h

@@ -0,0 +1,213 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineFriendsInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlineMessageInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Interfaces/OnlineSessionInterface.h"
+
+#include "GameFramework/GameModeBase.h"
+#include "GameFramework/GameSession.h"
+
+//#include "UObjectIterator.h"
+
+#include "AdvancedSessionsLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedSessionsLog, Log, All);
+
+
+UCLASS()
+class UAdvancedSessionsLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+		//********* Session Admin Functions *************//	
+
+		// Kick a player from the currently active game session, only available on the server
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions", meta = (WorldContext = "WorldContextObject"))
+		static bool KickPlayer(UObject* WorldContextObject, APlayerController* PlayerToKick, FText KickReason);
+
+		// Ban a player from the currently active game session, only available on the server
+		// Note that the default gamesession class does not implement an actual ban list and just kicks when this is called
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions", meta = (WorldContext = "WorldContextObject"))
+		static bool BanPlayer(UObject* WorldContextObject, APlayerController* PlayerToBan, FText BanReason);
+
+		//********* Session Search Functions *************//	
+
+		// Adds or modifies session settings in an existing array depending on if they exist already or not
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo")
+		static void AddOrModifyExtraSettings(UPARAM(ref)  TArray<FSessionPropertyKeyPair> & SettingsArray, UPARAM(ref)  TArray<FSessionPropertyKeyPair> & NewOrChangedSettings, TArray<FSessionPropertyKeyPair> & ModifiedSettingsArray);
+
+		// Get an array of the session settings from a session search result
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo")
+		static void GetExtraSettings(FBlueprintSessionResult SessionResult, TArray<FSessionPropertyKeyPair> & ExtraSettings);
+
+		// Get the current session state
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (WorldContext = "WorldContextObject"))
+		static void GetSessionState(UObject* WorldContextObject, EBPOnlineSessionState &SessionState);
+
+		// Get the current session settings
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "Result", WorldContext = "WorldContextObject"))
+		static void GetSessionSettings(UObject* WorldContextObject, int32 &NumConnections, int32 &NumPrivateConnections, bool &bIsLAN, bool &bIsDedicated, bool &bAllowInvites, bool &bAllowJoinInProgress, bool &bIsAnticheatEnabled, int32 &BuildUniqueID, TArray<FSessionPropertyKeyPair> &ExtraSettings, EBlueprintResultSwitch &Result);
+
+		// Check if someone is in the current session
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (WorldContext = "WorldContextObject"))
+		static void IsPlayerInSession(UObject* WorldContextObject, const FBPUniqueNetId &PlayerToCheck, bool &bIsInSession);
+		
+		// Make a literal session search parameter
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionsSearchSetting MakeLiteralSessionSearchProperty(FSessionPropertyKeyPair SessionSearchProperty, EOnlineComparisonOpRedux ComparisonOp);
+
+
+		//********* Session Information Functions ***********//
+
+		// Check if a session result is valid or not
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo")
+		static bool IsValidSession(const FBlueprintSessionResult & SessionResult);
+
+		// Get a string copy of a session ID
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo")
+		static void GetSessionID_AsString(const FBlueprintSessionResult & SessionResult, FString& SessionID);
+
+		// Get a string copy of the current session ID
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo", meta = (WorldContext = "WorldContextObject"))
+		static void GetCurrentSessionID_AsString(UObject* WorldContextObject, FString& SessionID);
+
+		// Get the Unique Current Build ID
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo")
+		static void GetCurrentUniqueBuildID(int32 &UniqueBuildId);
+		
+		// Get the Unique Build ID from a session search result
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo")
+		static void GetUniqueBuildID(FBlueprintSessionResult SessionResult, int32 &UniqueBuildId);
+		
+		
+		// Thanks CriErr for submission
+
+
+		// Get session property Key Name value
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo")
+		static FName GetSessionPropertyKey(const FSessionPropertyKeyPair& SessionProperty);
+		
+		// Find session property by Name
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "Result"))
+		static void FindSessionPropertyByName(const TArray<FSessionPropertyKeyPair>& ExtraSettings, FName SettingsName, EBlueprintResultSwitch &Result, FSessionPropertyKeyPair& OutProperty);
+		
+		// Find session property index by Name
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "Result"))
+		static void FindSessionPropertyIndexByName(const TArray<FSessionPropertyKeyPair>& ExtraSettings, FName SettingName, EBlueprintResultSwitch &Result, int32& OutIndex);
+
+		/// Removed the Index_None part of the last function, that isn't accessible in blueprint, better to return success/failure
+		// End Thanks CriErr :p
+
+		// Get session custom information key/value as Byte (For Enums)
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "SearchResult"))
+		static void GetSessionPropertyByte(const TArray<FSessionPropertyKeyPair> & ExtraSettings, FName SettingName, ESessionSettingSearchResult &SearchResult, uint8 &SettingValue);
+
+		// Get session custom information key/value as Bool
+		// Steam only currently supports Int,Float,String,BYTE values for search filtering!!!
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "SearchResult"))
+		static void GetSessionPropertyBool(const TArray<FSessionPropertyKeyPair> & ExtraSettings, FName SettingName, ESessionSettingSearchResult &SearchResult, bool &SettingValue);
+
+		// Get session custom information key/value as String
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "SearchResult"))
+		static void GetSessionPropertyString(const TArray<FSessionPropertyKeyPair> & ExtraSettings, FName SettingName, ESessionSettingSearchResult &SearchResult, FString &SettingValue);
+
+		// Get session custom information key/value as Int
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "SearchResult"))
+		static void GetSessionPropertyInt(const TArray<FSessionPropertyKeyPair> & ExtraSettings, FName SettingName, ESessionSettingSearchResult &SearchResult, int32 &SettingValue);
+
+		// Get session custom information key/value as Float
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|SessionInfo", meta = (ExpandEnumAsExecs = "SearchResult"))
+		static void GetSessionPropertyFloat(const TArray<FSessionPropertyKeyPair> & ExtraSettings, FName SettingName, ESessionSettingSearchResult &SearchResult, float &SettingValue);
+
+
+		// Make a literal session custom information key/value pair from Byte (For Enums)
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionPropertyKeyPair MakeLiteralSessionPropertyByte(FName Key, uint8 Value);
+
+		// Make a literal session custom information key/value pair from Bool
+		// Steam only currently supports Int,Float,String,BYTE values for search filtering!
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionPropertyKeyPair MakeLiteralSessionPropertyBool(FName Key, bool Value);
+
+		// Make a literal session custom information key/value pair from String
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionPropertyKeyPair MakeLiteralSessionPropertyString(FName Key, FString Value);
+
+		// Make a literal session custom information key/value pair from Int
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionPropertyKeyPair MakeLiteralSessionPropertyInt(FName Key, int32 Value);
+
+		// Make a literal session custom information key/value pair from Float
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|SessionInfo|Literals")
+		static FSessionPropertyKeyPair MakeLiteralSessionPropertyFloat(FName Key, float Value);
+
+
+		//******* Player ID functions *********//
+
+		// Get the unique net id of a network player attached to the given controller
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|PlayerID")
+		static void GetUniqueNetID(APlayerController *PlayerController, FBPUniqueNetId &UniqueNetId);
+
+		// Get the unique net id of a network player who is assigned the the given player state
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|PlayerID")
+		static void GetUniqueNetIDFromPlayerState(APlayerState *PlayerState, FBPUniqueNetId &UniqueNetId);
+		
+		// Return True if Unique Net ID is valid
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|PlayerID")
+		static bool IsValidUniqueNetID(const FBPUniqueNetId &UniqueNetId);
+
+		/* Returns true if the values are equal (A == B) */
+		UFUNCTION(BlueprintPure, meta = (DisplayName = "Equal Unique Net ID", CompactNodeTitle = "==", Keywords = "== equal"), Category = "Online|AdvancedSessions|PlayerInfo|PlayerID")
+		static bool EqualEqual_UNetIDUnetID(const FBPUniqueNetId &A, const FBPUniqueNetId &B);
+
+		/** Converts a FBPUniqueNetID into a FUniqueNetID_Repl */
+		UFUNCTION(BlueprintPure, meta = (DisplayName = "ToUniqueNetIDRepl (Unique Net ID)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Online|AdvancedSessions|PlayerInfo|PlayerID")
+			static FUniqueNetIdRepl Conv_BPUniqueIDToUniqueNetIDRepl(const FBPUniqueNetId& InUniqueID);
+
+		// Check if a UniqueNetId is a friend
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|UniqueNetId")
+		static void UniqueNetIdToString(const FBPUniqueNetId &UniqueNetId, FString &String);
+
+		//******** Player Name Functions **********//
+
+		// Get the player name of a network player attached to the given controller
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|PlayerName")
+		static void GetPlayerName(APlayerController *PlayerController, FString &PlayerName);
+
+		// Set the player name of a network player attached to the given controller
+		UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSessions|PlayerInfo|PlayerName")
+		static void SetPlayerName(APlayerController *PlayerController, FString PlayerName);
+
+		//********** Misc Player Info Functions *********//
+
+		// Get the number of network players
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|Misc", meta = (bIgnoreSelf = "true", WorldContext = "WorldContextObject", DisplayName = "GetNumNetworkPlayers"))
+		static void GetNumberOfNetworkPlayers(UObject* WorldContextObject, int32 &NumNetPlayers);
+
+		// Get the network player index of the given controller
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|PlayerInfo|Misc")
+		static void GetNetPlayerIndex(APlayerController *PlayerController, int32 &NetPlayerIndex);
+
+		// Checks if the stated session subsystem is active
+		UFUNCTION(BlueprintPure, Category = "Online|AdvancedSessions|Misc")
+		static bool HasOnlineSubsystem(FName SubSystemName);
+
+		//**** Seamless travel Functions ****//
+
+		//Exposes Server travel to blueprint
+		UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "Online|AdvancedSessions|Seamless", meta = (HidePin = "WorldContextObject", DefaultToSelf = "WorldContextObject"))
+		static bool ServerTravel(UObject* WorldContextObject, const FString& InURL, bool bAbsolute, bool bShouldSkipGameNotify);
+		
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AdvancedVoiceLibrary.h

@@ -0,0 +1,99 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "BlueprintDataDefinitions.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/VoiceInterface.h"
+//#include "OnlineFriendsInterface.h"
+//#include "OnlineUserInterface.h"
+//#include "OnlineMessageInterface.h"
+//#include "OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+//#include "OnlineSessionInterface.h"
+
+#include "UObject/UObjectIterator.h"
+
+#include "AdvancedVoiceLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedVoiceLog, Log, All);
+
+
+UCLASS()
+class UAdvancedVoiceLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	
+	//********* Voice Library Functions *************//
+
+	// Get if a headset is present for the specified local user
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedVoice|VoiceInfo", meta = (WorldContext = "WorldContextObject"))
+	static void IsHeadsetPresent(UObject* WorldContextObject, bool & bHasHeadset, uint8 LocalPlayerNum = 0);
+
+	// Starts networked voice, allows push to talk in coordination with StopNetworkedVoice
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void StartNetworkedVoice(UObject* WorldContextObject, uint8 LocalPlayerNum = 0);
+
+	// Stops networked voice, allows push to talk in coordination with StartNetworkedVoice
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void StopNetworkedVoice(UObject* WorldContextObject, uint8 LocalPlayerNum = 0);
+
+	// Registers a local player as someone interested in voice data
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static bool RegisterLocalTalker(UObject* WorldContextObject, uint8 LocalPlayerNum = 0);
+
+	// Registers all signed in players as local talkers
+	// This is already done automatically, only do it manually if you unregistered someone
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void RegisterAllLocalTalkers(UObject* WorldContextObject);
+
+	// UnRegisters local player as a local talker
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void UnRegisterLocalTalker(UObject* WorldContextObject, uint8 LocalPlayerNum = 0);
+
+	// UnRegisters all signed in players as local talkers
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void UnRegisterAllLocalTalkers(UObject* WorldContextObject);
+
+	// Registers a remote player as a talker
+	// This is already done automatically, only do it manually if you unregistered someone
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static bool RegisterRemoteTalker(UObject* WorldContextObject, const FBPUniqueNetId& UniqueNetId);
+
+	// UnRegisters a remote player as a talker
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static bool UnRegisterRemoteTalker(UObject* WorldContextObject, const FBPUniqueNetId& UniqueNetId);
+
+	// UnRegisters all remote players as talkers
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static void RemoveAllRemoteTalkers(UObject* WorldContextObject);
+
+	// Returns whether a local player is currently talking
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedVoice|VoiceInfo", meta = (WorldContext = "WorldContextObject"))
+	static bool IsLocalPlayerTalking(UObject* WorldContextObject, uint8 LocalPlayerNum);
+
+	// Returns whether a remote player is currently talking
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedVoice|VoiceInfo", meta = (WorldContext = "WorldContextObject"))
+	static bool IsRemotePlayerTalking(UObject* WorldContextObject, const FBPUniqueNetId& UniqueNetId);
+
+	// Returns whether a player is muted for the specified local player
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedVoice|VoiceInfo", meta = (WorldContext = "WorldContextObject"))
+	static bool IsPlayerMuted(UObject* WorldContextObject, uint8 LocalUserNumChecking, const FBPUniqueNetId& UniqueNetId);
+
+	// Mutes the player associated with the uniquenetid for the specified local player, if IsSystemWide is true then it will attempt to mute globally for the player
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static bool MuteRemoteTalker(UObject* WorldContextObject, uint8 LocalUserNum, const FBPUniqueNetId& UniqueNetId, bool bIsSystemWide = false);
+
+	// UnMutes the player associated with the uniquenetid for the specified local player, if IsSystemWide is true then it will attempt to unmute globally for the player
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedVoice", meta = (WorldContext = "WorldContextObject"))
+	static bool UnMuteRemoteTalker(UObject* WorldContextObject, uint8 LocalUserNum, const FBPUniqueNetId& UniqueNetId, bool bIsSystemWide = false);
+
+	// Gets the number of local talkers for this system
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedVoice|VoiceInfo", meta = (WorldContext = "WorldContextObject"))
+	static void GetNumLocalTalkers(UObject* WorldContextObject, int32 & NumLocalTalkers);
+};	

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/AutoLoginUserCallbackProxy.h

@@ -0,0 +1,55 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Interfaces/OnlineIdentityInterface.h"
+#include "Engine/LocalPlayer.h"
+#include "AutoLoginUserCallbackProxy.generated.h"
+
+UCLASS(MinimalAPI)
+class UAutoLoginUserCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when there is a successful destroy
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnSuccess;
+
+	// Called when there is an unsuccessful destroy
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnFailure;
+
+	/**
+	 * Logs the player into the online service using parameters passed on the
+	 * command line. Expects -AUTH_LOGIN=<UserName> -AUTH_PASSWORD=<password>. If either
+	 * are missing, the function returns false and doesn't start the login
+	 * process
+	 *
+	 * @param LocalUserNum the controller number of the associated user
+	 *
+	 */
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedIdentity")
+	static UAutoLoginUserCallbackProxy* AutoLoginUser(UObject* WorldContextObject, int32 LocalUserNum);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	// Internal callback when the operation completes, calls out to the public success/failure callbacks
+	void OnCompleted(int32 LocalUserNum, bool bWasSuccessful, const FUniqueNetId& UserId, const FString& ErrorVal);
+
+private:
+	// The controller number of the associated user
+	int32 LocalUserNumber;
+
+	// The delegate executed by the online subsystem
+	FOnLoginCompleteDelegate Delegate;
+
+	// Handle to the registered OnDestroySessionComplete delegate
+	FDelegateHandle DelegateHandle;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/BlueprintDataDefinitions.h

@@ -0,0 +1,435 @@
+#pragma once
+#include "CoreMinimal.h"
+//#include "EngineMinimal.h"
+#include "Engine/Engine.h"
+#include "GameFramework/PlayerState.h"
+//#include "Core.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "OnlineSessionSettings.h"
+#include "OnlineDelegateMacros.h"
+#include "OnlineSubsystem.h"
+#include "OnlineSubsystemImpl.h"
+#include "OnlineSubsystemUtils.h"
+#include "OnlineSubsystemUtilsModule.h"
+#include "GameFramework/PlayerController.h"
+#include "Modules/ModuleManager.h"
+#include "OnlineSubsystemUtilsClasses.h"
+#include "BlueprintDataDefinitions.generated.h"	
+
+UENUM(BlueprintType)
+enum class EBPUserPrivileges : uint8
+{
+	/** Whether the user can play at all, online or offline - may be age restricted */
+	CanPlay,
+	/** Whether the user can play in online modes */
+	CanPlayOnline,
+	/** Whether the user can use voice and text chat */
+	CanCommunicateOnline,
+	/** Whether the user can use content generated by other users */
+	CanUseUserGeneratedContent
+};
+
+
+UENUM(BlueprintType)
+enum class EBPLoginStatus : uint8
+{
+	/** Player has not logged in or chosen a local profile */
+	NotLoggedIn,
+	/** Player is using a local profile but is not logged in */
+	UsingLocalProfile,
+	/** Player has been validated by the platform specific authentication service */
+	LoggedIn
+};
+
+
+USTRUCT(BlueprintType)
+struct FBPUserOnlineAccount
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+	TSharedPtr<FUserOnlineAccount> UserAccountInfo;
+
+	FBPUserOnlineAccount()
+	{
+
+	}
+
+	FBPUserOnlineAccount(TSharedPtr<FUserOnlineAccount> UserAccount)
+	{
+		UserAccountInfo = UserAccount;
+	}
+};
+
+UENUM()
+enum class ESessionSettingSearchResult : uint8
+{
+	// Found the setting
+	Found,
+
+	// Did not find the setting
+	NotFound,
+
+	// Was not the correct type
+	WrongType
+};
+
+// This makes a lot of the blueprint functions cleaner
+UENUM()
+enum class EBlueprintResultSwitch : uint8
+{
+	// On Success
+	OnSuccess,
+
+	// On Failure
+	OnFailure
+};
+
+// This makes a lot of the blueprint functions cleaner
+UENUM()
+enum class EBlueprintAsyncResultSwitch : uint8
+{
+	// On Success
+	OnSuccess,
+
+	// Still loading
+	AsyncLoading,
+	// On Failure
+	OnFailure
+};
+
+// This is to define server type searches
+UENUM(BlueprintType)
+enum class EBPServerPresenceSearchType : uint8
+{
+	AllServers,
+	ClientServersOnly,
+	DedicatedServersOnly
+};
+
+// Wanted this to be switchable in the editor
+UENUM(BlueprintType)
+enum class EBPOnlinePresenceState : uint8
+{
+	Online,
+	Offline,
+	Away,
+	ExtendedAway,
+	DoNotDisturb,
+	Chat
+};
+
+UENUM(BlueprintType)
+enum class EBPOnlineSessionState : uint8
+{
+	/** An online session has not been created yet */
+	NoSession,
+	/** An online session is in the process of being created */
+	Creating,
+	/** Session has been created but the session hasn't started (pre match lobby) */
+	Pending,
+	/** Session has been asked to start (may take time due to communication with backend) */
+	Starting,
+	/** The current session has started. Sessions with join in progress disabled are no longer joinable */
+	InProgress,
+	/** The session is still valid, but the session is no longer being played (post match lobby) */
+	Ending,
+	/** The session is closed and any stats committed */
+	Ended,
+	/** The session is being destroyed */
+	Destroying
+};
+
+// Boy oh boy is this a dirty hack, but I can't figure out a good way to do it otherwise at the moment
+// The UniqueNetId is an abstract class so I can't exactly re-initialize it to make a shared pointer on some functions
+// So I made the blueprintable UniqueNetID into a dual variable struct with access functions and I am converting the const var for the pointer
+// I really need to re-think this later
+USTRUCT(BlueprintType)
+struct FBPUniqueNetId
+{
+	GENERATED_USTRUCT_BODY()
+
+private:
+	bool bUseDirectPointer;
+
+
+public:
+	TSharedPtr<const FUniqueNetId> UniqueNetId;
+	const FUniqueNetId * UniqueNetIdPtr;
+
+	void SetUniqueNetId(const TSharedPtr<const FUniqueNetId> &ID)
+	{
+		bUseDirectPointer = false;
+		UniqueNetIdPtr = nullptr;
+		UniqueNetId = ID;
+	}
+
+	void SetUniqueNetId(const FUniqueNetId *ID)
+	{
+		bUseDirectPointer = true;
+		UniqueNetIdPtr = ID;
+	}
+
+	bool IsValid() const
+	{
+		if (bUseDirectPointer && UniqueNetIdPtr != nullptr && UniqueNetIdPtr->IsValid())
+		{
+			return true;
+		}
+		else if (UniqueNetId.IsValid())
+		{
+			return true;
+		}
+		else
+			return false;
+
+	}
+
+	const FUniqueNetId* GetUniqueNetId() const
+	{
+		if (bUseDirectPointer && UniqueNetIdPtr != nullptr)
+		{
+			// No longer converting to non const as all functions now pass const UniqueNetIds
+			return /*const_cast<FUniqueNetId*>*/(UniqueNetIdPtr);
+		}
+		else if (UniqueNetId.IsValid())
+		{
+			return UniqueNetId.Get();
+		}
+		else
+			return nullptr;
+	}
+
+	// Adding in a compare operator so that std functions will work with this struct
+	FORCEINLINE bool operator==(const FBPUniqueNetId& Other) const
+	{
+		return (IsValid() && Other.IsValid() && (*GetUniqueNetId() == *Other.GetUniqueNetId()));
+	}
+
+	FORCEINLINE bool operator!=(const FBPUniqueNetId& Other) const
+	{
+		return !(IsValid() && Other.IsValid() && (*GetUniqueNetId() == *Other.GetUniqueNetId()));
+	}
+
+	FBPUniqueNetId()
+	{
+		bUseDirectPointer = false;
+		UniqueNetIdPtr = nullptr;
+	}
+};
+
+USTRUCT(BluePrintType)
+struct FBPOnlineUser
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		FBPUniqueNetId UniqueNetId;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		FString DisplayName;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		FString RealName;
+};
+
+USTRUCT(BluePrintType)
+struct FBPOnlineRecentPlayer : public FBPOnlineUser
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		FString LastSeen;
+};
+
+
+USTRUCT(BlueprintType)
+struct FBPFriendPresenceInfo
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		bool bIsOnline = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		bool bIsPlaying = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		bool bIsPlayingThisGame = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		bool bIsJoinable = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		bool bHasVoiceSupport = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		EBPOnlinePresenceState PresenceState = EBPOnlinePresenceState::Offline;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+		FString StatusString;
+
+	FBPFriendPresenceInfo()
+	{
+		bIsOnline = false;
+		bIsPlaying = false;
+		bIsPlayingThisGame = false;
+		bIsJoinable = false;
+		bHasVoiceSupport = false;
+		PresenceState = EBPOnlinePresenceState::Offline;
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FBPFriendInfo
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	FString DisplayName;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	FString RealName;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	EBPOnlinePresenceState OnlineState = EBPOnlinePresenceState::Offline;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	FBPUniqueNetId UniqueNetId;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	bool bIsPlayingSameGame = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Online|Friend")
+	FBPFriendPresenceInfo PresenceInfo;
+
+	FBPFriendInfo()
+	{
+		OnlineState = EBPOnlinePresenceState::Offline;
+		bIsPlayingSameGame = false;
+	}
+};
+
+
+/** The types of comparison operations for a given search query */
+// Used to compare session properties
+UENUM(BlueprintType)
+enum class EOnlineComparisonOpRedux : uint8
+{
+	Equals,
+	NotEquals,
+	GreaterThan,
+	GreaterThanEquals,
+	LessThan,
+	LessThanEquals,
+};
+
+
+// Used to store session properties before converting to FVariantData
+USTRUCT(BlueprintType)
+struct FSessionPropertyKeyPair
+{
+	GENERATED_USTRUCT_BODY()
+
+	FName Key;
+	FVariantData Data;
+};
+
+
+// Sent to the FindSessionsAdvanced to filter the end results
+USTRUCT(BlueprintType)
+struct FSessionsSearchSetting
+{
+	GENERATED_USTRUCT_BODY()
+	//UPROPERTY()
+
+
+	// Had to make a copy of this to account for the original not being exposed to blueprints
+	/** How is this session setting compared on the backend searches */
+	EOnlineComparisonOpRedux ComparisonOp;
+
+	// The key pair to search for
+	FSessionPropertyKeyPair PropertyKeyPair;
+};
+
+// Couldn't use the default one as it is not exposed to other modules, had to re-create it here
+// Helper class for various methods to reduce the call hierarchy
+struct FOnlineSubsystemBPCallHelperAdvanced
+{
+public:
+	FOnlineSubsystemBPCallHelperAdvanced(const TCHAR* CallFunctionContext, UWorld* World, FName SystemName = NAME_None)
+		: OnlineSub(Online::GetSubsystem(World, SystemName))
+		, FunctionContext(CallFunctionContext)
+	{
+		if (OnlineSub == nullptr)
+		{
+			FFrame::KismetExecutionMessage(*FString::Printf(TEXT("%s - Invalid or uninitialized OnlineSubsystem"), FunctionContext), ELogVerbosity::Warning);
+		}
+	}
+
+	void QueryIDFromPlayerController(APlayerController* PlayerController)
+	{
+		UserID.Reset();
+		//return const_cast<FUniqueNetId*>(UniqueNetIdPtr);
+		if (APlayerState* PlayerState = (PlayerController != NULL) ? PlayerController->PlayerState : NULL)
+		{
+			UserID = PlayerState->GetUniqueId().GetUniqueNetId();
+			if (!UserID.IsValid())
+			{
+				FFrame::KismetExecutionMessage(*FString::Printf(TEXT("%s - Cannot map local player to unique net ID"), FunctionContext), ELogVerbosity::Warning);
+			}
+		}
+		else
+		{
+			FFrame::KismetExecutionMessage(*FString::Printf(TEXT("%s - Invalid player state"), FunctionContext), ELogVerbosity::Warning);
+		}
+	}
+
+
+	bool IsValid() const
+	{
+		return UserID.IsValid() && (OnlineSub != nullptr);
+	}
+
+public:
+	//TSharedPtr<const FUniqueNetId>& GetUniqueNetId()
+	TSharedPtr</*class*/ const FUniqueNetId> UserID;
+	IOnlineSubsystem* const OnlineSub;
+	const TCHAR* FunctionContext;
+};
+class FOnlineSearchSettingsEx : public FOnlineSearchSettings
+{
+	/**
+	*	Sets a key value pair combination that defines a search parameter
+	*
+	* @param Key key for the setting
+	* @param Value value of the setting
+	* @param InType type of comparison
+	*/
+public:
+
+	void HardSet(FName Key, const FVariantData& Value, EOnlineComparisonOpRedux CompOp)
+	{
+		FOnlineSessionSearchParam* SearchParam = SearchParams.Find(Key);
+
+		TEnumAsByte<EOnlineComparisonOp::Type> op;
+
+		switch (CompOp)
+		{
+		case EOnlineComparisonOpRedux::Equals: op = EOnlineComparisonOp::Equals; break;
+		case EOnlineComparisonOpRedux::GreaterThan: op = EOnlineComparisonOp::GreaterThan; break;
+		case EOnlineComparisonOpRedux::GreaterThanEquals: op = EOnlineComparisonOp::GreaterThanEquals; break;
+		case EOnlineComparisonOpRedux::LessThan: op = EOnlineComparisonOp::LessThan; break;
+		case EOnlineComparisonOpRedux::LessThanEquals: op = EOnlineComparisonOp::LessThanEquals; break;
+		case EOnlineComparisonOpRedux::NotEquals: op = EOnlineComparisonOp::NotEquals; break;
+		default: op = EOnlineComparisonOp::Equals; break;
+		}
+
+		if (SearchParam)
+		{
+			SearchParam->Data = Value;
+			SearchParam->ComparisonOp = op;
+		}
+		else
+		{
+			FOnlineSessionSearchParam searchSetting((int)0, op);
+			searchSetting.Data = Value;
+			SearchParams.Add(Key, searchSetting);
+		}
+	}
+};
+
+#define INVALID_INDEX -1