Merged in tutorialmodules-release-2.19.2 (pull request #477)

Update tutorialmodules to 2.19.2

* Update tutorialmodules to 2.19.2

* chore: version


Approved-by: Nauval Muhammad Firdaus
Approved-by: Damar Inderajati

Author: Byte Wars Build Pipeline

Config/Custom/EOS/DefaultEngine.ini

@@ -7,4 +7,5 @@ bEnabled=true
 [/Script/OnlineSubsystemEOS.EOSSettings]
 DefaultArtifactName=
 +Artifacts=(ArtifactName="",ProductId="",SandboxId="",DeploymentId="",ClientId="",ClientSecret="",EncryptionKey="1111111111111111111111111111111111111111111111111111111")
-bUseEAS=True
+bUseEAS=True
+bEnableOverlay=True

Config/DefaultGame.ini

@@ -1,8 +1,8 @@
 [/Script/EngineSettings.GeneralProjectSettings]
-GitHash=fb254a2
+GitHash=4456143
 ProjectID=8DAB8AD246B954A7292553AF4B4F50E5
-ProjectVersion=2.19.1
-BuildNumber=304
+ProjectVersion=2.19.2
+BuildNumber=312
 
 [/Script/CommonInput.CommonInputSettings]
 InputData=/Game/ByteWars/UI/Input/B_AccelByteWarsCommonInputData.B_AccelByteWarsCommonInputData_C

Plugins/AccelByte/AccelByteUe4Sdk

@@ -42,6 +42,18 @@ class ACCELBYTEWARS_API FNativePlatformPurchaseUtils
 	static inline FString RegionalCurrencyCode;
 };
 
+UCLASS(Config = Engine, DefaultConfig) // reads/writes from DefaultEngine.ini
+class ACCELBYTEWARS_API UEpicGamesStoreItemConfig : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	// AGS required Audience Item ID, while Game Client can only fetch the OfferId.
+	// Key = AudienceId, Value = OfferId
+	UPROPERTY(Config, EditAnywhere, Category = "Offers")
+	TMap<FString, FString> AudienceOffers;
+};
+
 static inline TArray<TSharedRef<FAccelByteModelsItemMapping>> GooglePlayItemMapping =
 {
 	MakeShared<FAccelByteModelsItemMapping>(FAccelByteModelsItemMapping{

Plugins/AccelByte/OnlineSubsystemAccelByte

@@ -5,9 +5,12 @@
 #include "NativePlatformPurchaseSubsystem.h"
 
 #include "Algo/Transform.h"
+#include "Interfaces/OnlineStoreInterfaceV2.h"
+#include "Interfaces/OnlineIdentityInterface.h"
 #include "OnlineStoreInterfaceV2AccelByte.h"
 #include "OnlineEntitlementsInterfaceAccelByte.h"
 #include "OnlinePurchaseInterfaceAccelByte.h"
+#include "OnlineIdentityInterfaceAccelByte.h"
 #include "Monetization/InGameStoreEssentials/UI/ShopWidget.h"
 #include "Monetization/InGameStoreEssentials/InGameStoreEssentialsModel.h"
 
@@ -19,6 +22,12 @@ void UNativePlatformPurchaseSubsystem::Initialize(FSubsystemCollectionBase& Coll
 
 	const IOnlineSubsystem* Subsystem = Online::GetSubsystem(GetWorld());
 	ensure(Subsystem);
+
+	const IOnlineIdentityPtr IdentityPtr = Subsystem->GetIdentityInterface();
+	ensure(IdentityPtr);
+	IdentityInterface = StaticCastSharedPtr<FOnlineIdentityAccelByte>(IdentityPtr);
+	ensure(IdentityInterface);
+
 	const IOnlineStoreV2Ptr StorePtr = Subsystem->GetStoreV2Interface();
 	ensure(StorePtr);
 	StoreInterface = StaticCastSharedPtr<FOnlineStoreV2AccelByte>(StorePtr);
@@ -149,6 +158,9 @@ void UNativePlatformPurchaseSubsystem::CheckoutItem(const APlayerController* Own
 	 * This is necessary because the AccelByte OSS does not natively support this setup.*/
 	CheckoutItemWithGooglePlay(OwningPlayer, CheckoutRequest, StoreItemData->GetIsConsumable());
 	return;
+#elif PLATFORM_EOS
+	CheckoutItemWithEpic(OwningPlayer, CheckoutRequest);
+	return;
 #endif
 
 	const FAccelByteModelsEntitlementSyncBase EntitlementSyncBase = { *NativeProductId };
@@ -212,6 +224,15 @@ void UNativePlatformPurchaseSubsystem::OnQueryItemMappingComplete(
 
 #if PLATFORM_STEAM
 	OnQueryItemMappingCompleted.ExecuteIfBound(GetSteamItemPricing(ItemMappings));
+#elif PLATFORM_EOS
+	if (!GetItemPrices().IsEmpty())
+	{
+		OnQueryItemMappingCompleted.ExecuteIfBound(GetItemPrices());
+	}
+	else
+	{
+		QueryEpicItems(UserId, ItemMappings);
+	}
 #elif PLATFORM_ANDROID
 	// Query native item information from Google Play Games Services (GPGS) if not yet.
 	if (!GetItemPrices().IsEmpty()) 
@@ -436,6 +457,179 @@ void UNativePlatformPurchaseSubsystem::HandleSteamPurchaseOverlay(GameOverlayAct
 #endif
 #pragma endregion
 
+#pragma region "Epic Games Store"
+#if PLATFORM_EOS
+void UNativePlatformPurchaseSubsystem::QueryEpicItems(const FUniqueNetIdPtr UserId, const TArray<TSharedRef<FAccelByteModelsItemMapping>>& ItemMappings)
+{
+	const IOnlineSubsystem* PlatformSubsystem = IOnlineSubsystem::GetByPlatform();
+	if (!PlatformSubsystem)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. The native platform subsystem is invalid."));
+		return;
+	}
+
+	IOnlineStoreV2Ptr PlatformStore = PlatformSubsystem->GetStoreV2Interface();
+	if (!PlatformStore)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. The native store v2 interface is invalid."));
+		return;
+	}
+
+	IOnlineIdentityPtr PlatformIdentity = PlatformSubsystem->GetIdentityInterface();
+	if (!PlatformIdentity)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. The native identity interface is invalid."));
+		return;
+	}
+
+	TArray<FString> OfferIds;
+	const UEpicGamesStoreItemConfig* ItemConfigs = GetDefault<UEpicGamesStoreItemConfig>();
+	if (!ItemConfigs)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. Unable to load UEpicGamesStoreItemConfig."));
+		return;
+	}
+
+	for (const TSharedRef<FAccelByteModelsItemMapping>& OfferId : ItemMappings)
+	{
+		if (OfferId->Platform == EAccelBytePlatformMapping::EPIC_GAMES)
+		{
+			OfferIds.Add(ItemConfigs->AudienceOffers[OfferId->PlatformProductId]);
+		}
+	}
+
+	FPlatformUserId PlatformUserId = IdentityInterface->GetPlatformUserIdFromUniqueNetId(UserId.ToSharedRef().Get());
+	ensure(PlatformUserId.IsValid());
+	const int32 LocalUserNum = IdentityInterface->GetLocalUserNumFromPlatformUserId(PlatformUserId);
+
+	FUniqueNetIdPtr PlatformUniqueId = PlatformIdentity->GetUniquePlayerId(LocalUserNum);
+	ensure(PlatformUniqueId.IsValid());
+
+	PlatformStore->QueryOffersById(*PlatformUniqueId, OfferIds, FOnQueryOnlineStoreOffersComplete::CreateUObject(this, &ThisClass::OnEpicQueryOfferCompleted));
+}
+
+void UNativePlatformPurchaseSubsystem::OnEpicQueryOfferCompleted(bool bWasSuccessful, const TArray<FUniqueOfferId>& OfferIds, const FString& Error)
+{
+	if (!bWasSuccessful)
+	{
+		OnQueryItemMappingCompleted.ExecuteIfBound({});
+		return;
+	}
+
+	const IOnlineSubsystem* PlatformSubsystem = IOnlineSubsystem::GetByPlatform();
+	if (!PlatformSubsystem)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. The native platform subsystem is invalid."));
+		return;
+	}
+
+	IOnlineStoreV2Ptr PlatformStore = PlatformSubsystem->GetStoreV2Interface();
+	if (!PlatformStore)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. The native store v2 interface is invalid."));
+		return;
+	}
+
+	const UEpicGamesStoreItemConfig* ItemConfigs = GetDefault<UEpicGamesStoreItemConfig>();
+	if (!ItemConfigs)
+	{
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to query native pricing. Unable to load UEpicGamesStoreItemConfig."));
+		return;
+	}
+
+	TArray<FOnlineStoreOfferRef> Offers;
+	PlatformStore->GetOffers(Offers);
+
+	TMap<FString, FString> AbItemMapping;
+	for (const TSharedRef<FAccelByteModelsItemMapping>& OfferId : GetItemMapping())
+	{
+		if (OfferId->Platform == EAccelBytePlatformMapping::EPIC_GAMES)
+		{
+			if (const FString* EpicOfferId = ItemConfigs->AudienceOffers.Find(OfferId->PlatformProductId))
+			{
+				AbItemMapping.Add(**EpicOfferId, OfferId->ItemIdentity);
+			}
+		}
+	}
+
+	ItemPriceMap.Empty();
+	for (const FOnlineStoreOfferRef& Offer : Offers)
+	{
+		const FString& PlatformProductId = Offer->OfferId;
+		if (!PlatformProductId.IsEmpty() && AbItemMapping.Contains(PlatformProductId))
+		{
+			ItemPriceMap.Add(AbItemMapping[PlatformProductId], {PlatformProductId, (uint64)Offer->NumericPrice});
+			FNativePlatformPurchaseUtils::RegionalCurrencyCode = Offer->CurrencyCode;
+		}
+	}
+
+	OnQueryItemMappingCompleted.ExecuteIfBound(ItemPriceMap);
+}
+
+void UNativePlatformPurchaseSubsystem::CheckoutItemWithEpic(const APlayerController* OwningPlayer, const FPurchaseCheckoutRequest CheckoutRequest)
+{
+	FString ErrorMessage = TEXT("");
+
+	const IOnlineSubsystem* PlatformSubsystem = IOnlineSubsystem::GetByPlatform();
+	if (!PlatformSubsystem)
+	{
+		ErrorMessage = TEXT("Failed to checkout item using Epic Online Service. Identity interface is invalid.");
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("%s"), *ErrorMessage);
+		OnSyncPurchaseCompleteDelegates.ExecuteIfBound(false, ErrorMessage);
+		return;
+	}
+
+	IOnlinePurchasePtr PlatformPurchase = PlatformSubsystem->GetPurchaseInterface();
+	if (!PlatformPurchase)
+	{
+		ErrorMessage = TEXT("Failed to checkout item using Epic Online Service. Purchase interface is invalid.");
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("%s"), *ErrorMessage);
+		OnSyncPurchaseCompleteDelegates.ExecuteIfBound(false, ErrorMessage);
+		return;
+	}
+
+	const ULocalPlayer* LocalPlayer = OwningPlayer->GetLocalPlayer();
+	if (!LocalPlayer)
+	{
+		ErrorMessage = TEXT("Failed to checkout item using Epic Online Services. Local Player is invalid.");
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("%s"), *ErrorMessage);
+		OnSyncPurchaseCompleteDelegates.ExecuteIfBound(false, ErrorMessage);
+		return;
+	}
+
+	const int32 LocalUserNum = LocalPlayer->GetControllerId();
+	IOnlineIdentityPtr PlatformIdentity = PlatformSubsystem->GetIdentityInterface();
+	const FUniqueNetIdPtr UserId = PlatformIdentity->GetUniquePlayerId(LocalUserNum);
+	if (!UserId)
+	{
+		ErrorMessage = TEXT("Failed to checkout item using Epic Online Services. User ID is invalid.");
+		UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("%s"), *ErrorMessage);
+		OnSyncPurchaseCompleteDelegates.ExecuteIfBound(false, ErrorMessage);
+		return;
+	}
+
+	PlatformPurchase->Checkout(*UserId, CheckoutRequest,
+		FOnPurchaseCheckoutComplete::CreateWeakLambda(this,
+			[this, LocalUserNum, PlatformIdentity]
+			(const FOnlineError& Result, const TSharedRef<FPurchaseReceipt>& Receipt)
+			{
+				if (!Result.bSucceeded)
+				{
+					UE_LOG_NATIVE_PLATFORM_PURCHASE(Warning, TEXT("Failed to purchase item using Epic Online Services. Error: %s"), *Result.ErrorMessage.ToString());
+					OnSyncPurchaseCompleteDelegates.ExecuteIfBound(false, Result.ErrorMessage.ToString());
+					return;
+				}
+
+				// Sync Epic Online Services purchase with AccelByte.
+				UE_LOG_NATIVE_PLATFORM_PURCHASE(Log, TEXT("Success to purchase item using Epic Online Services. Synching purchase to AccelByte"));
+				PurchaseSyncState = EPurchaseState::SyncInProgress;
+				EntitlementInterface->SyncPlatformPurchase(LocalUserNum, FAccelByteModelsEntitlementSyncBase{}, OnSyncPurchaseCompleteDelegates);
+			})
+	);
+}
+#endif
+#pragma endregion
+
 #pragma region "Google Play"
 #if PLATFORM_ANDROID
 void UNativePlatformPurchaseSubsystem::CheckoutItemWithGooglePlay(

Source/AccelByteWars/TutorialModules/Monetization/NativePlatformPurchase/NativePlatformPurchaseModels.h

@@ -59,6 +59,7 @@ class ACCELBYTEWARS_API UNativePlatformPurchaseSubsystem : public UTutorialModul
 	FOnQueryItemMappingCompleted OnQueryItemMappingCompleted;
 
 private:
+	FOnlineIdentityAccelBytePtr IdentityInterface;
 	FOnlineStoreV2AccelBytePtr StoreInterface;
 	FOnlineEntitlementsAccelBytePtr EntitlementInterface;
 	FOnlinePurchaseAccelBytePtr PurchaseInterface;
@@ -104,7 +105,17 @@ class ACCELBYTEWARS_API UNativePlatformPurchaseSubsystem : public UTutorialModul
 	TMap<int32, uint64> SteamItemPrices;
 #endif
 #pragma endregion
-	
+
+#pragma region "Epic Games Store"
+#if PLATFORM_EOS
+	void QueryEpicItems(const FUniqueNetIdPtr UserId, const TArray<TSharedRef<FAccelByteModelsItemMapping>>& ItemMappings);
+	void OnEpicQueryOfferCompleted(bool bWasSuccessful, const TArray<FUniqueOfferId>& OfferIds, const FString& Error);
+	void CheckoutItemWithEpic(
+		const APlayerController* OwningPlayer,
+		const FPurchaseCheckoutRequest CheckoutRequest);
+#endif
+#pragma endregion
+
 #pragma region "Google Play"
 #if PLATFORM_ANDROID
 	void CheckoutItemWithGooglePlay(
@@ -139,6 +150,7 @@ class ACCELBYTEWARS_API UNativePlatformPurchaseSubsystem : public UTutorialModul
 		{ EAccelBytePlatformType::Steam, EAccelBytePlatformMapping::STEAM },
 		{ EAccelBytePlatformType::Google, EAccelBytePlatformMapping::GOOGLE },
 		{ EAccelBytePlatformType::GooglePlayGames, EAccelBytePlatformMapping::GOOGLE },
+		{ EAccelBytePlatformType::EpicGames, EAccelBytePlatformMapping::EPIC_GAMES },
 	};
 
 	const TArray<EAccelByteItemType> SupportedNativePlatformItem = { EAccelByteItemType::COINS };

Source/AccelByteWars/TutorialModules/Monetization/NativePlatformPurchase/NativePlatformPurchaseSubsystem.cpp

@@ -14,6 +14,7 @@
 #include "Interfaces/OnlinePresenceInterface.h"
 #include "FriendsEssentialsModels.generated.h"
 
+#define INVALID_SEARCH_FRIEND_KEYWORD_LENGTH_MESSAGE NSLOCTEXT("AccelByteWars", "Invalid search friend keyword length", "Keyword must be between {0} and {1} characters long.")
 #define ALREADY_FRIEND_REASON_MESSAGE NSLOCTEXT("AccelByteWars", "Already friend", "Already friend")
 #define BEEN_INVITED_REASON_MESSAGE NSLOCTEXT("AccelByteWars", "You've been invited", "You've been invited")
 #define ALREADY_INVITED_REASON_MESSAGE NSLOCTEXT("AccelByteWars", "Already invited", "Already invited")

Source/AccelByteWars/TutorialModules/Monetization/NativePlatformPurchase/NativePlatformPurchaseSubsystem.h

@@ -7,6 +7,7 @@
 #include "Core/UI/Components/Prompt/PromptSubsystem.h"
 #include "OnlineSubsystemUtils.h"
 #include "TutorialModuleUtilities/StartupSubsystem.h"
+#include "TutorialModuleUtilities/TutorialModuleOnlineUtility.h"
 
 #define LOCTEXT_NAMESPACE "AccelByteWars"
 
@@ -217,6 +218,15 @@ void UFriendsSubsystem::GetSelfFriendCode(const APlayerController* PC, const FOn
 // @@@SNIPSTART FriendsSubsystem.cpp-FindFriend
 void UFriendsSubsystem::FindFriend(const APlayerController* PC, const FString& InKeyword, const FOnFindFriendComplete& OnComplete)
 {
+	const FIAMPublicSystemConfigResponse& PublicSystemConfig = UTutorialModuleOnlineUtility::GetPublicSystemConfig();
+	const int32 MinLen = PublicSystemConfig.SearchQueryMinLength, MaxLen = PublicSystemConfig.SearchQueryMaxLength;
+	if (InKeyword.Len() < MinLen || InKeyword.Len() > MaxLen)
+	{
+		UE_LOG_FRIENDS_ESSENTIALS(Warning, TEXT("Cannot find a friend. Keyword must be between %d and %d characters long."), MinLen, MaxLen);
+		OnComplete.ExecuteIfBound(false, nullptr, FText::Format(INVALID_SEARCH_FRIEND_KEYWORD_LENGTH_MESSAGE, FText::AsNumber(MinLen), FText::AsNumber(MaxLen)).ToString());
+		return;
+	}
+
 	if (!ensure(FriendsInterface) || !ensure(UserInterface))
 	{
 		UE_LOG_FRIENDS_ESSENTIALS(Warning, TEXT("Cannot find a friend. Friends Interface or User Interface is not valid."));

Source/AccelByteWars/TutorialModules/Social/FriendsEssentials/FriendsEssentialsModels.h

@@ -7,6 +7,7 @@
 #include "Core/UI/Components/Prompt/PromptSubsystem.h"
 #include "OnlineSubsystemUtils.h"
 #include "TutorialModuleUtilities/StartupSubsystem.h"
+#include "TutorialModuleUtilities/TutorialModuleOnlineUtility.h"
 
 #define LOCTEXT_NAMESPACE "AccelByteWars"