Merge remote-tracking branch 'origin/Monolith-Testing' into PilotMovement

# Conflicts:
#	Content/FirstPerson/Blueprints/BP_FirstPersonCharacter.uasset

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,18 @@ 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)
++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

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

@@ -0,0 +1,46 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "BlueprintDataDefinitions.h"
+#include "CancelFindSessionsCallbackProxy.generated.h"
+
+UCLASS(MinimalAPI)
+class UCancelFindSessionsCallbackProxy : 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;
+
+	// Cancels finding sessions
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedSessions")
+	static UCancelFindSessionsCallbackProxy* CancelFindSessions(UObject* WorldContextObject, class APlayerController* PlayerController);
+
+	// 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(bool bWasSuccessful);
+
+private:
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed by the online subsystem
+	FOnCancelFindSessionsCompleteDelegate 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/CreateSessionCallbackProxyAdvanced.h

@@ -0,0 +1,107 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "BlueprintDataDefinitions.h"
+#include "CreateSessionCallbackProxyAdvanced.generated.h"
+
+UCLASS(MinimalAPI)
+class UCreateSessionCallbackProxyAdvanced : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the session was created successfully
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnSuccess;
+
+	// Called when there was an error creating the session
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnFailure;
+
+	/**
+	 *    Creates a session with the default online subsystem with advanced optional inputs, for dedicated servers leave UsePresence as false and set IsDedicatedServer to true. Dedicated servers don't use presence.
+	 *    @param PublicConnections	When doing a 'listen' server, this must be >=2 (ListenServer itself counts as a connection)
+	 *    @param bUseLAN			When you want to play LAN, the level to play on must be loaded with option 'bIsLanMatch'
+	 *    @param bUsePresence		Must be true for a 'listen' server (Map must be loaded with option 'listen'), false for a 'dedicated' server.
+	 *	  @param bUseLobbiesIfAvailable Used to flag the subsystem to use a lobby api instead of general hosting if the API supports it, generally true on steam for listen servers and false for dedicated
+	 *	  @param bShouldAdvertise	Set to true when the OnlineSubsystem should list your server when someone is searching for servers. Otherwise the server is hidden and only join via invite is possible.
+	 *	  @param bUseLobbiesVoiceChatIfAvailable Set to true to setup voice chat lobbies if the API supports it
+	 * 	  @param bStartAfterCreate Set to true to start the session after it's created. If false you need to manually call StartSession when ready.
+	 */
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject",AutoCreateRefTerm="ExtraSettings"), Category = "Online|AdvancedSessions")
+		static UCreateSessionCallbackProxyAdvanced* CreateAdvancedSession(UObject* WorldContextObject, const TArray<FSessionPropertyKeyPair>& ExtraSettings, class APlayerController* PlayerController = NULL, int32 PublicConnections = 100, int32 PrivateConnections = 0, bool bUseLAN = false, bool bAllowInvites = true, bool bIsDedicatedServer = false, bool bUsePresence = true, bool bUseLobbiesIfAvailable = true, bool bAllowJoinViaPresence = true, bool bAllowJoinViaPresenceFriendsOnly = false, bool bAntiCheatProtected = false, bool bUsesStats = false, bool bShouldAdvertise = true, bool bUseLobbiesVoiceChatIfAvailable = false, bool bStartAfterCreate = true);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	// Internal callback when session creation completes, optionally calls StartSession
+	void OnCreateCompleted(FName SessionName, bool bWasSuccessful);
+
+	// Internal callback when session start completes
+	void OnStartCompleted(FName SessionName, bool bWasSuccessful);
+
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed by the online subsystem
+	FOnCreateSessionCompleteDelegate CreateCompleteDelegate;
+
+	// The delegate executed by the online subsystem
+	FOnStartSessionCompleteDelegate StartCompleteDelegate;
+
+	// Handles to the registered delegates above
+	FDelegateHandle CreateCompleteDelegateHandle;
+	FDelegateHandle StartCompleteDelegateHandle;
+
+	// Number of public connections
+	int NumPublicConnections;
+
+	// Number of private connections
+	int NumPrivateConnections;
+
+	// Whether or not to search LAN
+	bool bUseLAN;
+
+	// Whether or not to allow invites
+	bool bAllowInvites;
+
+	// Whether this is a dedicated server or not
+	bool bDedicatedServer;
+
+	// Whether to use the presence option
+	bool bUsePresence;
+
+	// Whether to prefer the use of lobbies for hosting if the api supports them
+	bool bUseLobbiesIfAvailable;
+
+	// Whether to allow joining via presence
+	bool bAllowJoinViaPresence;
+
+	// Allow joining via presence for friends only
+	bool bAllowJoinViaPresenceFriendsOnly;
+
+	// Delcare the server to be anti cheat protected
+	bool bAntiCheatProtected;
+
+	// Record Stats
+	bool bUsesStats;
+
+	// Should advertise server?
+	bool bShouldAdvertise;
+
+	// Whether to prefer the use of voice chat lobbies if the api supports them
+	bool bUseLobbiesVoiceChatIfAvailable;
+
+	// Whether to start the session automatically after it is created
+	bool bStartAfterCreate;
+
+	// Store extra settings
+	TArray<FSessionPropertyKeyPair> ExtraSettings;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

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

@@ -0,0 +1,49 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "BlueprintDataDefinitions.h"
+#include "EndSessionCallbackProxy.generated.h"
+
+UCLASS(MinimalAPI)
+class UEndSessionCallbackProxy : 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;
+
+	/**
+	 *	  Ends the current sessions, Generally for almost all uses you should be using the engines native Destroy Session node instead.
+	 *	  This exists for people using StartSession and optionally hand managing the session state.
+	 */
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedSessions")
+	static UEndSessionCallbackProxy* EndSession(UObject* WorldContextObject, class APlayerController* PlayerController);
+
+	// 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(FName SessionName, bool bWasSuccessful);
+
+private:
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed by the online subsystem
+	FOnEndSessionCompleteDelegate 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/FindFriendSessionCallbackProxy.h

@@ -0,0 +1,51 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Engine/LocalPlayer.h"
+#include "FindFriendSessionCallbackProxy.generated.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedFindFriendSessionLog, Log, All);
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FBlueprintFindFriendSessionDelegate, const TArray<FBlueprintSessionResult> &, SessionInfo);
+
+UCLASS(MinimalAPI)
+class UFindFriendSessionCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the friends list successfully was retrieved
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintFindFriendSessionDelegate OnSuccess;
+
+	// Called when there was an error retrieving the friends list
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintFindFriendSessionDelegate OnFailure;
+
+	// Attempts to get the current session that a friend is in
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedFriends")
+	static UFindFriendSessionCallbackProxy* FindFriendSession(UObject* WorldContextObject, APlayerController *PlayerController, const FBPUniqueNetId &FriendUniqueNetId);
+
+	virtual void Activate() override;
+
+private:
+	// Internal callback when the friends list is retrieved
+	void OnFindFriendSessionCompleted(int32 LocalPlayer, bool bWasSuccessful, const TArray<FOnlineSessionSearchResult>& SessionInfo);
+
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The UniqueNetID of the person to invite
+	FBPUniqueNetId cUniqueNetId;
+
+	// The delegate to call on completion
+	FOnFindFriendSessionCompleteDelegate OnFindFriendSessionCompleteDelegate;
+
+	// Handles to the registered delegates above
+	FDelegateHandle FindFriendSessionCompleteDelegateHandle;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

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

@@ -0,0 +1,109 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "FindSessionsCallbackProxy.h"
+#include "BlueprintDataDefinitions.h"
+#include "FindSessionsCallbackProxyAdvanced.generated.h"
+
+
+FORCEINLINE bool operator==(const FBlueprintSessionResult& A, const FBlueprintSessionResult& B)
+{
+	return (A.OnlineResult.IsValid() == B.OnlineResult.IsValid() && (A.OnlineResult.GetSessionIdStr() == B.OnlineResult.GetSessionIdStr()));
+}
+
+UCLASS(MinimalAPI)
+class UFindSessionsCallbackProxyAdvanced : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when there is a successful query
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintFindSessionsResultDelegate OnSuccess;
+
+	// Called when there is an unsuccessful query
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintFindSessionsResultDelegate OnFailure;
+
+	// Searches for advertised sessions with the default online subsystem and includes an array of filters
+	UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject", AutoCreateRefTerm="Filters"), Category = "Online|AdvancedSessions")
+	static UFindSessionsCallbackProxyAdvanced* FindSessionsAdvanced(UObject* WorldContextObject, class APlayerController* PlayerController, int32 MaxResults, bool bUseLAN, EBPServerPresenceSearchType ServerTypeToSearch, const TArray<FSessionsSearchSetting> &Filters, bool bEmptyServersOnly = false, bool bNonEmptyServersOnly = false, bool bSecureServersOnly = false, bool bSearchLobbies = true, int MinSlotsAvailable = 0);
+
+	static bool CompareVariants(const FVariantData &A, const FVariantData &B, EOnlineComparisonOpRedux Comparator);
+	
+	// Filters an array of session results by the given search parameters, returns a new array with the filtered results
+	UFUNCTION(BluePrintCallable, meta = (Category = "Online|AdvancedSessions"))
+	static void FilterSessionResults(const TArray<FBlueprintSessionResult> &SessionResults, const TArray<FSessionsSearchSetting> &Filters, TArray<FBlueprintSessionResult> &FilteredResults);
+	
+	// Removed, the default built in versions work fine in the normal FindSessionsCallbackProxy
+	/*UFUNCTION(BlueprintPure, Category = "Online|Session")
+	static int32 GetPingInMs(const FBlueprintSessionResult& Result);
+
+	UFUNCTION(BlueprintPure, Category = "Online|Session")
+	static FString GetServerName(const FBlueprintSessionResult& Result);
+
+	UFUNCTION(BlueprintPure, Category = "Online|Session")
+	static int32 GetCurrentPlayers(const FBlueprintSessionResult& Result);
+
+	UFUNCTION(BlueprintPure, Category = "Online|Session")
+	static int32 GetMaxPlayers(const FBlueprintSessionResult& Result);*/
+
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	// Internal callback when the session search completes, calls out to the public success/failure callbacks
+	void OnCompleted(bool bSuccess);
+
+	bool bRunSecondSearch;
+	bool bIsOnSecondSearch;
+
+	TArray<FBlueprintSessionResult> SessionSearchResults;
+
+private:
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed by the online subsystem
+	FOnFindSessionsCompleteDelegate Delegate;
+
+	// Handle to the registered OnFindSessionsComplete delegate
+	FDelegateHandle DelegateHandle;
+
+	// Object to track search results
+	TSharedPtr<FOnlineSessionSearch> SearchObject;
+	TSharedPtr<FOnlineSessionSearch> SearchObjectDedicated;
+
+	// Whether or not to search LAN
+	bool bUseLAN;
+
+	// Whether or not to search for dedicated servers
+	EBPServerPresenceSearchType ServerSearchType;
+
+	// Maximum number of results to return
+	int MaxResults;
+
+	// Store extra settings
+	TArray<FSessionsSearchSetting> SearchSettings;
+
+	// Search for empty servers only
+	bool bEmptyServersOnly;
+
+	// Search for non empty servers only
+	bool bNonEmptyServersOnly;
+
+	// Search for secure servers only
+	bool bSecureServersOnly;
+
+	// Search through lobbies
+	bool bSearchLobbies;
+
+	// Min slots requires to search
+	int MinSlotsAvailable;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};

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

@@ -0,0 +1,49 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Engine/LocalPlayer.h"
+#include "GetFriendsCallbackProxy.generated.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedGetFriendsLog, Log, All);
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FBlueprintGetFriendsListDelegate, const TArray<FBPFriendInfo>&, Results);
+
+UCLASS(MinimalAPI)
+class UGetFriendsCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the friends list successfully was retrieved
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGetFriendsListDelegate OnSuccess;
+
+	// Called when there was an error retrieving the friends list
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGetFriendsListDelegate OnFailure;
+
+	// Gets the players list of friends from the OnlineSubsystem and returns it, can be retrieved later with GetStoredFriendsList
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedFriends")
+	static UGetFriendsCallbackProxy* GetAndStoreFriendsList(UObject* WorldContextObject, class APlayerController* PlayerController);
+
+	virtual void Activate() override;
+
+private:
+	// Internal callback when the friends list is retrieved
+	void OnReadFriendsListCompleted(int32 LocalUserNum, bool bWasSuccessful, const FString& ListName, const FString& ErrorString);
+
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed
+	FOnReadFriendsListComplete FriendListReadCompleteDelegate;
+
+	// The Type of friends list to get
+	// Removed because all but the facebook interfaces don't even currently support anything but the default friends list.
+	//EBPFriendsLists FriendListToGet;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

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

@@ -0,0 +1,49 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "GetRecentPlayersCallbackProxy.generated.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedGetRecentPlayersLog, Log, All);
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FBlueprintGetRecentPlayersDelegate, const TArray<FBPOnlineRecentPlayer>&, Results);
+
+UCLASS(MinimalAPI)
+class UGetRecentPlayersCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the friends list successfully was retrieved
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGetRecentPlayersDelegate OnSuccess;
+
+	// Called when there was an error retrieving the friends list
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGetRecentPlayersDelegate OnFailure;
+
+	// Gets the list of recent players from the OnlineSubsystem and returns it, can be retrieved later with GetStoredRecentPlayersList, can fail if no recent players are found
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedFriends")
+	static UGetRecentPlayersCallbackProxy* GetAndStoreRecentPlayersList(UObject* WorldContextObject, const FBPUniqueNetId &UniqueNetId);
+
+	virtual void Activate() override;
+
+private:
+	// Internal callback when the friends list is retrieved
+	void OnQueryRecentPlayersCompleted(const FUniqueNetId &UserID, const FString &Namespace, bool bWasSuccessful, const FString& ErrorString);
+	// Handle to the registered OnFindSessionsComplete delegate
+	FDelegateHandle DelegateHandle;
+
+	// The player controller triggering things
+	//TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The UniqueNetID of the person to get recent players for
+	FBPUniqueNetId cUniqueNetId;
+
+	// The delegate executed
+	FOnQueryRecentPlayersCompleteDelegate QueryRecentPlayersCompleteDelegate;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

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

@@ -0,0 +1,45 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Interfaces/OnlineIdentityInterface.h"
+#include "GetUserPrivilegeCallbackProxy.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FBlueprintGetUserPrivilegeDelegate,/* const &FBPUniqueNetId, PlayerID,*/ EBPUserPrivileges, QueriedPrivilege, bool, HadPrivilege);
+
+UCLASS(MinimalAPI)
+class UGetUserPrivilegeCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when there is a successful destroy
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGetUserPrivilegeDelegate OnSuccess;
+
+	// Called when there is an unsuccessful destroy
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnFailure;
+
+	// Gets the privilage of the user
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedIdentity")
+	static UGetUserPrivilegeCallbackProxy* GetUserPrivilege(UObject* WorldContextObject, const EBPUserPrivileges & PrivilegeToCheck, const FBPUniqueNetId & PlayerUniqueNetID);
+
+	// 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(const FUniqueNetId& PlayerID, EUserPrivileges::Type Privilege, uint32 Result);
+
+private:
+	// The player controller triggering things
+	FBPUniqueNetId PlayerUniqueNetID;
+
+	// Privilege to check
+	EBPUserPrivileges UserPrivilege;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};

Plugins/AdvancedSessions/Source/AdvancedSessions/Classes/LoginUserCallbackProxy.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 "LoginUserCallbackProxy.generated.h"
+
+UCLASS(MinimalAPI)
+class ULoginUserCallbackProxy : 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 into the identity interface
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject", AdvancedDisplay = "AuthType"), Category = "Online|AdvancedIdentity")
+	static ULoginUserCallbackProxy* LoginUser(UObject* WorldContextObject, class APlayerController* PlayerController, FString UserID, FString UserToken, FString AuthType);
+
+	// 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 player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The user ID
+	FString UserID;
+
+	// The user pass / token
+	FString UserToken;
+
+	FString AuthType;
+
+	// 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/LogoutUserCallbackProxy.h

@@ -0,0 +1,47 @@
+// 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 "LogoutUserCallbackProxy.generated.h"
+
+UCLASS(MinimalAPI)
+class ULogoutUserCallbackProxy : 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 out of the identity interface
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedIdentity")
+	static ULogoutUserCallbackProxy* LogoutUser(UObject* WorldContextObject, class APlayerController* PlayerController);
+
+	// 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(int LocalUserNum, bool bWasSuccessful);
+
+private:
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The delegate executed by the online subsystem
+	FOnLogoutCompleteDelegate 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/OnlineSubSystemHeader.h

@@ -0,0 +1,27 @@
+#pragma once
+
+//#include "EngineMinimal.h"
+//#include "Core.h"
+//#include "OnlineSessionInterface.h"
+//#include "OnlineSessionSettings.h"
+//#include "OnlineDelegateMacros.h"
+//#include "OnlineSubsystem.h"
+//#include "OnlineSubsystemImpl.h"
+//#include "OnlineSubsystemUtils.h"
+//#include "OnlineSubsystemUtilsModule.h"
+//#include "ModuleManager.h"
+//#include "OnlineSubsystemUtilsClasses.h"
+//#include "BlueprintDataDefinitions.h"
+
+
+/*#include "VoiceEngineImpl.h"
+#include "VoiceInterfaceImpl.h"
+#include "Voice.h""
+*/
+
+// Found this in the steam controller, seems like a nice thought since steam is throwing errors
+// Disable crazy warnings that claim that standard C library is "deprecated".
+//#ifdef _MSC_VER
+//#pragma warning(push)
+//#pragma warning(disable:4996)
+//#endif

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

@@ -0,0 +1,49 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Engine/LocalPlayer.h"
+#include "SendFriendInviteCallbackProxy.generated.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedSendFriendInviteLog, Log, All);
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE(FBlueprintSendFriendInviteDelegate);
+
+UCLASS(MinimalAPI)
+class USendFriendInviteCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the friends list successfully was retrieved
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintSendFriendInviteDelegate OnSuccess;
+
+	// Called when there was an error retrieving the friends list
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintSendFriendInviteDelegate OnFailure;
+
+	// Adds a friend who is using the defined UniqueNetId, some interfaces do now allow this function to be called (INCLUDING STEAM)
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedFriends")
+	static USendFriendInviteCallbackProxy* SendFriendInvite(UObject* WorldContextObject, APlayerController *PlayerController, const FBPUniqueNetId &UniqueNetIDInvited);
+
+	virtual void Activate() override;
+
+private:
+	// Internal callback when the friends list is retrieved
+	void OnSendInviteComplete(int32 LocalPlayerNum, bool bWasSuccessful, const FUniqueNetId &InvitedPlayer, const FString &ListName, const FString &ErrorString);
+
+
+	// The player controller triggering things
+	TWeakObjectPtr<APlayerController> PlayerControllerWeakPtr;
+
+	// The UniqueNetID of the person to invite
+	FBPUniqueNetId cUniqueNetId;
+
+	// The delegate to call on completion
+	FOnSendInviteComplete OnSendInviteCompleteDelegate;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

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

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "StartSessionCallbackProxyAdvanced.generated.h"
+
+UCLASS(MinimalAPI)
+class UStartSessionCallbackProxyAdvanced : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+	// Called when the session starts successfully
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnSuccess;
+
+	// Called when there is an error starting the session
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnFailure;
+
+	/**
+	 * Starts a session with the default online subsystem. The session needs to be previously created by calling the "CreateAdvancedSession" node.
+	 * @param WorldContextObject
+	 */
+	UFUNCTION(
+		BlueprintCallable
+		, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject")
+		, Category = "Online|AdvancedSessions"
+	)
+	static UStartSessionCallbackProxyAdvanced* StartAdvancedSession(UObject* WorldContextObject);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	// Internal callback when session start completes
+	void OnStartCompleted(FName SessionName, bool bWasSuccessful);
+
+	// The delegate executed by the online subsystem
+	FOnStartSessionCompleteDelegate StartCompleteDelegate;
+
+	// Handles to the registered delegates above
+	FDelegateHandle StartCompleteDelegateHandle;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};

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

@@ -0,0 +1,69 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/Engine.h"
+#include "BlueprintDataDefinitions.h"
+#include "UpdateSessionCallbackProxyAdvanced.generated.h"
+
+UCLASS(MinimalAPI)
+class UUpdateSessionCallbackProxyAdvanced : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when the session was updated successfully
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnSuccess;
+
+	// Called when there was an error updating the session
+	UPROPERTY(BlueprintAssignable)
+	FEmptyOnlineDelegate OnFailure;
+
+	// Creates a session with the default online subsystem with advanced optional inputs, you MUST fill in all categories or it will pass in values that you didn't want as default values
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject",AutoCreateRefTerm="ExtraSettings"), Category = "Online|AdvancedSessions")
+	static UUpdateSessionCallbackProxyAdvanced* UpdateSession(UObject* WorldContextObject, const TArray<FSessionPropertyKeyPair> &ExtraSettings, int32 PublicConnections = 100, int32 PrivateConnections = 0, bool bUseLAN = false, bool bAllowInvites = false, bool bAllowJoinInProgress = false, bool bRefreshOnlineData = true, bool bIsDedicatedServer = false, bool bShouldAdvertise = true);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	// Internal callback when session creation completes, calls StartSession
+	void OnUpdateCompleted(FName SessionName, bool bWasSuccessful);
+
+	// The delegate executed by the online subsystem
+	FOnUpdateSessionCompleteDelegate OnUpdateSessionCompleteDelegate;
+
+	// Handles to the registered delegates above
+	FDelegateHandle OnUpdateSessionCompleteDelegateHandle;
+
+	// Number of public connections
+	int NumPublicConnections = 100;
+
+	// Number of private connections
+	int NumPrivateConnections = 0;
+
+	// Whether or not to search LAN
+	bool bUseLAN = false;
+
+	// Whether or not to allow invites
+	bool bAllowInvites = true;
+
+	// Store extra settings
+	TArray<FSessionPropertyKeyPair> ExtraSettings;
+
+	// Whether to update the online data
+	bool bRefreshOnlineData = true;
+
+	// Allow joining in progress
+	bool bAllowJoinInProgress = true;
+
+	// Update whether this is a dedicated server or not
+	bool bDedicatedServer = false;
+
+	bool bShouldAdvertise = true;
+
+	// The world context object in which this call is taking place
+	TWeakObjectPtr<UObject> WorldContextObject;
+};
+

Plugins/AdvancedSessions/Source/AdvancedSessions/Private/AdvancedExternalUILibrary.cpp

@@ -0,0 +1,209 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "AdvancedExternalUILibrary.h"
+#include "Engine/LocalPlayer.h"
+
+
+//General Log
+DEFINE_LOG_CATEGORY(AdvancedExternalUILog);
+
+void UAdvancedExternalUILibrary::ShowAccountUpgradeUI(UObject* WorldContextObject, const FBPUniqueNetId PlayerRequestingAccountUpgradeUI, EBlueprintResultSwitch &Result)
+{
+
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowAccountUpgradeUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ExternalUIInterface->ShowAccountUpgradeUI(*PlayerRequestingAccountUpgradeUI.GetUniqueNetId());
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedExternalUILibrary::ShowProfileUI(UObject* WorldContextObject, const FBPUniqueNetId PlayerViewingProfile, const FBPUniqueNetId PlayerToViewProfileOf, EBlueprintResultSwitch &Result)
+{
+
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowProfileUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+	
+	ExternalUIInterface->ShowProfileUI(*PlayerViewingProfile.GetUniqueNetId(), *PlayerToViewProfileOf.GetUniqueNetId(), NULL);
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+
+
+void UAdvancedExternalUILibrary::ShowWebURLUI(UObject* WorldContextObject, FString URLToShow, EBlueprintResultSwitch &Result, TArray<FString>& AllowedDomains, bool bEmbedded, bool bShowBackground, bool bShowCloseButton, int32 OffsetX, int32 OffsetY, int32 SizeX, int32 SizeY)
+{
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowWebURLUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	URLToShow = URLToShow.Replace(TEXT("http://"), TEXT(""));
+	URLToShow = URLToShow.Replace(TEXT("https://"), TEXT(""));
+
+	FShowWebUrlParams Params;
+	Params.AllowedDomains = AllowedDomains;
+	Params.bEmbedded = bEmbedded;
+	Params.bShowBackground = bShowBackground;
+	Params.bShowCloseButton = bShowCloseButton;
+	Params.OffsetX = OffsetX;
+	Params.OffsetY = OffsetY;
+	Params.SizeX = SizeX;
+	Params.SizeY = SizeY;
+
+	ExternalUIInterface->ShowWebURL(URLToShow, Params);
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedExternalUILibrary::CloseWebURLUI(UObject* WorldContextObject)
+{
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("CloseWebURLUI Failed to get External UI interface!"));
+		return;
+	}
+
+	ExternalUIInterface->CloseWebURL();
+}
+
+void UAdvancedExternalUILibrary::ShowLeaderBoardUI(UObject* WorldContextObject, FString LeaderboardName, EBlueprintResultSwitch &Result)
+{
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowLeaderboardsUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ExternalUIInterface->ShowLeaderboardUI(LeaderboardName);
+	Result = EBlueprintResultSwitch::OnSuccess;
+
+}
+
+
+void UAdvancedExternalUILibrary::ShowInviteUI(UObject* WorldContextObject, APlayerController *PlayerController, EBlueprintResultSwitch &Result)
+{
+	if (!PlayerController)
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowInviteUI Had a bad Player Controller!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowInviteUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerController->Player);
+
+	if (!Player)
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowInviteUI Failed to get ULocalPlayer for the given PlayerController!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ExternalUIInterface->ShowInviteUI(Player->GetControllerId(), NAME_GameSession);
+	Result = EBlueprintResultSwitch::OnSuccess;
+}
+
+void UAdvancedExternalUILibrary::ShowFriendsUI(UObject* WorldContextObject, APlayerController *PlayerController, EBlueprintResultSwitch &Result)
+{
+	if (!PlayerController)
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowFriendsUI Had a bad Player Controller!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	UWorld* const World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull);
+	if (!IsValid(World))
+	{
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	IOnlineExternalUIPtr ExternalUIInterface = Online::GetExternalUIInterface(World);
+
+	if (!ExternalUIInterface.IsValid())
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowFriendsUI Failed to get External UI interface!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ULocalPlayer* Player = Cast<ULocalPlayer>(PlayerController->Player);
+
+	if (!Player)
+	{
+		UE_LOG(AdvancedExternalUILog, Warning, TEXT("ShowFriendsUI Failed to get ULocalPlayer for the given PlayerController!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	ExternalUIInterface->ShowFriendsUI(Player->GetControllerId());
+	Result = EBlueprintResultSwitch::OnSuccess;
+}

Plugins/AdvancedSessions/Source/AdvancedSessions/Private/AdvancedFriendsGameInstance.cpp

@@ -0,0 +1,334 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "AdvancedFriendsGameInstance.h"
+#include "Kismet/GameplayStatics.h"
+#include "GameFramework/PlayerController.h"
+
+//General Log
+DEFINE_LOG_CATEGORY(AdvancedFriendsInterfaceLog);
+
+UAdvancedFriendsGameInstance::UAdvancedFriendsGameInstance(const FObjectInitializer& ObjectInitializer) 
+	: Super(ObjectInitializer)
+	, bCallFriendInterfaceEventsOnPlayerControllers(true)
+	, bCallIdentityInterfaceEventsOnPlayerControllers(true)
+	, bCallVoiceInterfaceEventsOnPlayerControllers(true)
+	, bEnableTalkingStatusDelegate(true)
+	, SessionInviteReceivedDelegate(FOnSessionInviteReceivedDelegate::CreateUObject(this, &ThisClass::OnSessionInviteReceivedMaster))
+	, SessionInviteAcceptedDelegate(FOnSessionUserInviteAcceptedDelegate::CreateUObject(this, &ThisClass::OnSessionInviteAcceptedMaster))
+	, PlayerTalkingStateChangedDelegate(FOnPlayerTalkingStateChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerTalkingStateChangedMaster))
+	, PlayerLoginChangedDelegate(FOnLoginChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerLoginChangedMaster))
+	, PlayerLoginStatusChangedDelegate(FOnLoginStatusChangedDelegate::CreateUObject(this, &ThisClass::OnPlayerLoginStatusChangedMaster))
+{
+}
+
+void UAdvancedFriendsGameInstance::Shutdown()
+{
+	IOnlineSessionPtr SessionInterface = Online::GetSessionInterface(GetWorld());
+	
+	if (!SessionInterface.IsValid())
+	{
+		UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsGameInstance Failed to get session system!"));
+		//return;
+	}
+	else
+	{
+		// Clear all of the delegate handles here
+		SessionInterface->ClearOnSessionUserInviteAcceptedDelegate_Handle(SessionInviteAcceptedDelegateHandle);
+		SessionInterface->ClearOnSessionInviteReceivedDelegate_Handle(SessionInviteReceivedDelegateHandle);
+	}
+
+
+	if (bEnableTalkingStatusDelegate)
+	{
+		IOnlineVoicePtr VoiceInterface = Online::GetVoiceInterface(GetWorld());
+
+		if (VoiceInterface.IsValid())
+		{
+			VoiceInterface->ClearOnPlayerTalkingStateChangedDelegate_Handle(PlayerTalkingStateChangedDelegateHandle);
+		}
+		else
+		{
+
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get voice interface!"));
+		}
+	}
+
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface(GetWorld());
+
+	if (IdentityInterface.IsValid())
+	{
+		IdentityInterface->ClearOnLoginChangedDelegate_Handle(PlayerLoginChangedDelegateHandle);
+		
+
+		// I am just defaulting to player 1
+		IdentityInterface->ClearOnLoginStatusChangedDelegate_Handle(0, PlayerLoginStatusChangedDelegateHandle);
+	}
+
+
+	Super::Shutdown();
+}
+
+void UAdvancedFriendsGameInstance::Init()
+{
+	IOnlineSessionPtr SessionInterface = Online::GetSessionInterface(GetWorld());//OnlineSub->GetSessionInterface();
+
+	if (SessionInterface.IsValid())
+	{
+		// Currently doesn't store a handle or assign a delegate to any local player beyond the first.....should handle?
+		// Thought about directly handling it but friends for multiple players probably isn't required
+		// Iterating through the local player TArray only works if it has had players assigned to it, most of the online interfaces don't support
+		// Multiple logins either (IE: Steam)
+		SessionInviteAcceptedDelegateHandle = SessionInterface->AddOnSessionUserInviteAcceptedDelegate_Handle(SessionInviteAcceptedDelegate);
+
+		SessionInviteReceivedDelegateHandle = SessionInterface->AddOnSessionInviteReceivedDelegate_Handle(SessionInviteReceivedDelegate);
+	}
+	else
+	{
+		UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get session interface!"));
+		//return;
+	}
+
+	// Beginning work on the voice interface
+	if (bEnableTalkingStatusDelegate)
+	{
+		IOnlineVoicePtr VoiceInterface = Online::GetVoiceInterface(GetWorld());
+
+		if (VoiceInterface.IsValid())
+		{
+			PlayerTalkingStateChangedDelegateHandle = VoiceInterface->AddOnPlayerTalkingStateChangedDelegate_Handle(PlayerTalkingStateChangedDelegate);
+		}
+		else
+		{
+
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get voice interface!"));
+		}
+	}
+
+	IOnlineIdentityPtr IdentityInterface = Online::GetIdentityInterface(GetWorld());
+
+	if (IdentityInterface.IsValid())
+	{
+		PlayerLoginChangedDelegateHandle = IdentityInterface->AddOnLoginChangedDelegate_Handle(PlayerLoginChangedDelegate);
+
+		// Just defaulting to player 1
+		PlayerLoginStatusChangedDelegateHandle = IdentityInterface->AddOnLoginStatusChangedDelegate_Handle(0, PlayerLoginStatusChangedDelegate);
+	}
+	else
+	{
+		UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get identity interface!"));
+	}
+
+
+	Super::Init();
+}
+
+/*void UAdvancedFriendsGameInstance::PostLoad()
+{
+	Super::PostLoad();
+}*/
+
+
+// Removed because it never gets called by the online subsystems
+/*void UAdvancedFriendsGameInstance::OnSessionInviteReceivedMaster(const FUniqueNetId &InvitedPlayer, const FUniqueNetId &FriendInviting, const FOnlineSessionSearchResult& Session)
+{
+	// Just call the blueprint event to let the user handle this
+
+	FBPUniqueNetId IP, FI;
+
+	IP.SetUniqueNetId(&InvitedPlayer);
+
+	FI.SetUniqueNetId(&FriendInviting);
+
+	FBlueprintSessionResult BPS;
+	BPS.OnlineResult = Session;
+	OnSessionInviteReceived(IP,FI,BPS);
+
+	TArray<class APlayerState*>& PlayerArray = GetWorld()->GetGameState()->PlayerArray;
+	const TArray<class ULocalPlayer*>&ControllerArray = this->GetLocalPlayers();
+
+	for (int i = 0; i < ControllerArray.Num(); i++)
+	{
+		if (*PlayerArray[ControllerArray[i]->PlayerController->NetPlayerIndex]->UniqueId.GetUniqueNetId().Get() == InvitedPlayer)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (ControllerArray[i]->PlayerController->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnSessionInviteReceived(ControllerArray[i]->PlayerController, FI, BPS);
+			}
+			break;
+		}
+	}
+}*/
+
+void UAdvancedFriendsGameInstance::OnPlayerLoginStatusChangedMaster(int32 PlayerNum, ELoginStatus::Type PreviousStatus, ELoginStatus::Type NewStatus, const FUniqueNetId & NewPlayerUniqueNetID)
+{
+	EBPLoginStatus OrigStatus = (EBPLoginStatus)PreviousStatus;
+	EBPLoginStatus CurrentStatus = (EBPLoginStatus)NewStatus;
+	FBPUniqueNetId PlayerID;
+	PlayerID.SetUniqueNetId(&NewPlayerUniqueNetID);
+
+	OnPlayerLoginStatusChanged(PlayerNum, OrigStatus,CurrentStatus,PlayerID);
+
+
+	if (bCallIdentityInterfaceEventsOnPlayerControllers)
+	{
+		APlayerController* Player = UGameplayStatics::GetPlayerController(GetWorld(), PlayerNum);
+
+		if (Player != NULL)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnPlayerLoginStatusChanged(Player, OrigStatus, CurrentStatus, PlayerID);
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnPlayerLoginStatusChangedMaster!"));
+		}
+	}
+}
+
+void UAdvancedFriendsGameInstance::OnPlayerLoginChangedMaster(int32 PlayerNum)
+{
+	OnPlayerLoginChanged(PlayerNum);
+
+	if (bCallIdentityInterfaceEventsOnPlayerControllers)
+	{
+		APlayerController* Player = UGameplayStatics::GetPlayerController(GetWorld(), PlayerNum);
+
+		if (Player != NULL)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnPlayerLoginChanged(Player, PlayerNum);
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnPlayerLoginChanged!"));
+		}
+	}
+}
+
+void UAdvancedFriendsGameInstance::OnPlayerTalkingStateChangedMaster(TSharedRef<const FUniqueNetId> PlayerId, bool bIsTalking)
+{
+	FBPUniqueNetId PlayerTalking;
+	PlayerTalking.SetUniqueNetId(PlayerId);
+	OnPlayerTalkingStateChanged(PlayerTalking, bIsTalking);
+
+	if (bCallVoiceInterfaceEventsOnPlayerControllers)
+	{
+		APlayerController* Player = NULL;
+
+		for (const ULocalPlayer* LPlayer : LocalPlayers)
+		{
+			Player = UGameplayStatics::GetPlayerController(GetWorld(), LPlayer->GetControllerId());
+
+			if (Player != NULL)
+			{
+				//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+				if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+				{
+					IAdvancedFriendsInterface::Execute_OnPlayerVoiceStateChanged(Player, PlayerTalking, bIsTalking);
+				}
+			}
+			else
+			{
+				UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnVoiceStateChanged!"));
+			}
+		}
+	}
+}
+
+void UAdvancedFriendsGameInstance::OnSessionInviteReceivedMaster(const FUniqueNetId & PersonInvited, const FUniqueNetId & PersonInviting, const FString& AppId, const FOnlineSessionSearchResult& SessionToJoin)
+{
+	if (SessionToJoin.IsValid())
+	{
+		FBlueprintSessionResult BluePrintResult;
+		BluePrintResult.OnlineResult = SessionToJoin;
+
+		FBPUniqueNetId PInvited;
+		PInvited.SetUniqueNetId(&PersonInvited);
+
+		FBPUniqueNetId PInviting;
+		PInviting.SetUniqueNetId(&PersonInviting);
+
+
+		TArray<APlayerController*> PlayerList;
+		GEngine->GetAllLocalPlayerControllers(PlayerList);
+
+		APlayerController* Player = NULL;
+
+		int32 LocalPlayer = 0;
+		for (int i = 0; i < PlayerList.Num(); i++)
+		{
+			if (*PlayerList[i]->PlayerState->GetUniqueId().GetUniqueNetId() == PersonInvited)
+			{
+				LocalPlayer = i;
+				Player = PlayerList[i];
+				break;
+			}
+		}
+
+		OnSessionInviteReceived(LocalPlayer, PInviting, AppId, BluePrintResult);
+
+		//IAdvancedFriendsInterface* TheInterface = NULL;
+
+		if (Player != NULL)
+		{
+			//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+			if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+			{
+				IAdvancedFriendsInterface::Execute_OnSessionInviteReceived(Player, PInviting, BluePrintResult);
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnSessionInviteReceived!"));
+		}
+	}
+	else
+	{
+		UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Return a bad search result in OnSessionInviteReceived!"));
+	}
+}
+
+void UAdvancedFriendsGameInstance::OnSessionInviteAcceptedMaster(const bool bWasSuccessful, int32 LocalPlayer, TSharedPtr<const FUniqueNetId> PersonInvited, const FOnlineSessionSearchResult& SessionToJoin)
+{
+	if (bWasSuccessful)
+	{
+		if (SessionToJoin.IsValid())
+		{
+
+			FBlueprintSessionResult BluePrintResult;
+			BluePrintResult.OnlineResult = SessionToJoin;
+
+			FBPUniqueNetId PInvited;
+			PInvited.SetUniqueNetId(PersonInvited);
+
+			OnSessionInviteAccepted(LocalPlayer,PInvited, BluePrintResult);
+
+			APlayerController* Player = UGameplayStatics::GetPlayerController(GetWorld(), LocalPlayer);
+
+			//IAdvancedFriendsInterface* TheInterface = NULL;
+
+			if (Player != NULL)
+			{
+				//Run the Event specific to the actor, if the actor has the interface, otherwise ignore
+				if (Player->GetClass()->ImplementsInterface(UAdvancedFriendsInterface::StaticClass()))
+				{
+					IAdvancedFriendsInterface::Execute_OnSessionInviteAccepted(Player,PInvited, BluePrintResult);
+				}
+			}
+			else
+			{ 
+				UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Failed to get a controller with the specified index in OnSessionInviteAccepted!"));
+			}
+		}
+		else
+		{
+			UE_LOG(AdvancedFriendsInterfaceLog, Warning, TEXT("UAdvancedFriendsInstance Return a bad search result in OnSessionInviteAccepted!"));
+		}
+	}
+}

Plugins/AdvancedSessions/Source/AdvancedSessions/Private/AdvancedFriendsInterface.cpp

@@ -0,0 +1,9 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "AdvancedFriendsInterface.h"
+
+
+
+UAdvancedFriendsInterface::UAdvancedFriendsInterface(const class FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}