Implementation for the Sockets system.

Plugins/GenericItemization/Source/GenericItemization/Private/GenericItemizationInstanceTypes.cpp

@@ -37,6 +37,17 @@ void FAffixInstance::SetAffixDefinition(const FDataTableRowHandle& Handle)
 /* Items
 /************************************************************************/
 
+FItemSocketInstance::FItemSocketInstance()
+{
+	SocketId = FGuid::NewGuid();
+	bIsEmpty = false;
+}
+
+const FConstStructView FItemSocketInstance::GetSocketedItem() const
+{
+	return FConstStructView(SocketedItemInstance);
+}
+
 FItemInstance::FItemInstance()
 {
 	ItemId = FGuid::NewGuid();
@@ -110,6 +121,8 @@ bool FItemInstance::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOu
 	SafeNetSerializeTArray_WithNetSerialize<31>(Ar, ReplicatedAffixes, Map); // @NOTE: This means we have a practical maximum of 32 Affixes per ItemInstance. Should we expose this somehow?
 	if (Ar.IsLoading())
 	{
+		// We need to empty the actual array as we are effectively rebuilding it.
+		Affixes.Empty(ReplicatedAffixes.Num());
 		for (const FInstancedStruct& ReplicatedAffix : ReplicatedAffixes)
 		{
 			TInstancedStruct<FAffixInstance> Affix;
@@ -118,6 +131,31 @@ bool FItemInstance::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOu
 		}
 	}
 
+	// Ar << Sockets;
+	TArray<FInstancedStruct> ReplicatedSockets;
+	if (Ar.IsSaving())
+	{
+		for (const TInstancedStruct<FItemSocketInstance>& Socket : Sockets)
+		{
+			FInstancedStruct ReplicatedSocket;
+			ReplicatedSocket.InitializeAs(Socket.GetScriptStruct(), Socket.GetMemory());
+			ReplicatedSockets.Add(ReplicatedSocket);
+		}
+	}
+	SafeNetSerializeTArray_WithNetSerialize<31>(Ar, ReplicatedSockets, Map); // @NOTE: This means we have a practical maximum of 32 Sockets per ItemInstance. Should we expose this somehow?
+	if (Ar.IsLoading())
+	{
+		// We need to empty the actual array as we are effectively rebuilding it.
+		Sockets.Empty(ReplicatedSockets.Num());
+		for (const FInstancedStruct& ReplicatedSocket : ReplicatedSockets)
+		{
+			TInstancedStruct<FItemSocketInstance> Socket;
+			Socket.InitializeAsScriptStruct(ReplicatedSocket.GetScriptStruct(), ReplicatedSocket.GetMemory());
+
+			AddSocket(Socket);
+		}
+	}
+
 	bOutSuccess = true;
 	return true;
 }
@@ -135,6 +173,40 @@ void FItemInstance::SetItemDefinition(const FDataTableRowHandle& Handle)
 	}
 }
 
+void FItemInstance::AddSocket(TInstancedStruct<FItemSocketInstance>& NewSocket)
+{
+	// Let the Socket know what its definition is.
+	FSetSocketInstanceSocketDefinition(ItemDefinition.GetPtr(), NewSocket.GetMutablePtr());
+	Sockets.Add(NewSocket);
+}
+
+TOptional<const FConstStructView> FItemInstance::GetSocket(FGuid SocketId) const
+{
+	TOptional<const FConstStructView> Result;
+	for (const TInstancedStruct<FItemSocketInstance>& Socket : Sockets)
+	{
+		if (Socket.Get().SocketId == SocketId)
+		{
+			Result.Emplace(FConstStructView(Socket.GetScriptStruct(), Socket.GetMemory()));
+		}
+	}
+
+	return Result;
+}
+
+bool FItemInstance::HasSocket(FGuid SocketId) const
+{
+	for (const TInstancedStruct<FItemSocketInstance>& Socket : Sockets)
+	{
+		if (Socket.Get().SocketId == SocketId)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
 void FFastItemInstance::Initialize(FInstancedStruct& InItemInstance, FInstancedStruct& InUserContextData)
 {
 	ItemInstance = InItemInstance;

Plugins/GenericItemization/Source/GenericItemization/Private/GenericItemizationInstancingFunctions.cpp

@@ -6,6 +6,7 @@
 #include "GenericItemizationInstanceTypes.h"
 #include "GenericItemizationPickFunctions.h"
 #include "GameplayTagsManager.h"
+#include "ItemManagement/ItemSocketSettings.h"
 
 UItemInstancingFunction::UItemInstancingFunction()
 {
@@ -203,6 +204,40 @@ bool UItemInstancingFunction::CalculateStackCount_Implementation(const FInstance
 	return true;
 }
 
+bool UItemInstancingFunction::DetermineActiveSockets_Implementation(const FInstancedStruct& ItemInstance, const FInstancedStruct& ItemInstancingContext, TArray<int32>& OutActiveSocketDefinitions) const
+{
+	const FItemInstance* ItemInstancePtr = ItemInstance.GetPtr<FItemInstance>();
+	if (!ItemInstancePtr)
+	{
+		return false;
+	}
+
+	const TInstancedStruct<FItemDefinition>& ItemDefinitionInstance = ItemInstancePtr->GetItemDefinition();
+	if (!ItemDefinitionInstance.IsValid())
+	{
+		return false;
+	}
+
+	const FItemDefinition& ItemDefinition = ItemDefinitionInstance.Get();
+	if (ItemDefinition.bStacksOverSockets)
+	{
+		// If we are using Stacking functionality instead of Socketing functionality, then we can exit early with no default Active Sockets.
+		OutActiveSocketDefinitions.Empty();
+		return true;
+	}
+
+	const UItemSocketSettings* const ItemSocketSettingsCDO = ItemDefinition.SocketSettings.GetDefaultObject();
+	if (!ItemSocketSettingsCDO)
+	{
+		// This isn't necessarily a failure case.
+		OutActiveSocketDefinitions.Empty();
+		return true;
+	}
+
+	// By default we let the ItemSocketSettings decide what to do.
+	return ItemSocketSettingsCDO->DetermineActiveSockets(ItemInstance, ItemInstancingContext, OutActiveSocketDefinitions);
+}
+
 bool UItemInstancingContextFunction::BuildItemInstancingContext_Implementation(const UItemDropperComponent* ItemDropperComponent, const FInstancedStruct& UserContextData, FInstancedStruct& OutItemInstancingContext)
 {
 	// Override to provide your own context. 

Plugins/GenericItemization/Source/GenericItemization/Private/GenericItemizationStatics.cpp

@@ -10,6 +10,7 @@
 #include "StructView.h"
 #include "Engine/DataTable.h"
 #include "Kismet/KismetSystemLibrary.h"
+#include "ItemManagement/ItemSocketSettings.h"
 
 TOptional<TInstancedStruct<FItemDropTableType>> UGenericItemizationStatics::PickDropTableCollectionEntry(const TInstancedStruct<FItemDropTableCollectionRow>& DropTableCollectionEntry, const FInstancedStruct& ItemInstancingContext, bool bIncludeNoPick)
 {
@@ -393,6 +394,38 @@ bool UGenericItemizationStatics::GenerateItemInstanceFromItemDefinition(const FD
 		MutableItemInstance->StackCount = FMath::Max(1, DesiredStackCount);
 	}
 
+	// =====================================================================================
+	// 6. Assign all of the Sockets to the ItemInstance that it has access to.
+	// Also activate those that need to be from the InstancingFunction and by extension the SocketSettings.
+	{
+		TArray<int32> SocketsToActivate;
+		bool bDeterminedSocketsToActivate = InstancingFunctionCDO->DetermineActiveSockets(NewItemInstance, ItemInstancingContext, SocketsToActivate);
+		if (bDeterminedSocketsToActivate)
+		{
+			// Add all of the Sockets that the ItemSocketSettings is saying the ItemInstance needs to have.
+			const UItemSocketSettings* const ItemSocketSettingsCDO = ItemInstanceItemDefinition.Get().SocketSettings.GetDefaultObject();
+			if (ItemSocketSettingsCDO)
+			{
+				const int32 MaximumSocketCount = ItemInstanceItemDefinition.Get().MaximumSocketCount;
+				int32 SocketCount = MaximumSocketCount >= 0 ? MaximumSocketCount : INT_MAX;
+				for (const TInstancedStruct<FItemSocketDefinition>& SocketDefintion : ItemSocketSettingsCDO->GetSocketDefinitions(SocketsToActivate))
+				{
+					if(SocketCount > 0)
+					{
+						FItemSocketInstance NewSocket;
+						NewSocket.SocketDefinitionHandle = SocketDefintion.Get().SocketDefinitionHandle;
+						NewSocket.bIsEmpty = true; // Empty by default.
+
+						TInstancedStruct<FItemSocketInstance> SocketInstance = TInstancedStruct<FItemSocketInstance>::Make(NewSocket);
+						MutableItemInstance->AddSocket(SocketInstance);
+					}
+
+					SocketCount--;
+				}
+			}
+		}
+	}
+
 	OutItemInstance = NewItemInstance;
 	return true;
 }
@@ -418,3 +451,45 @@ bool UGenericItemizationStatics::GenerateItemInstanceFromTemplate(const FInstanc
 
 	return true;
 }
+
+bool UGenericItemizationStatics::GetItemAffixes(const TInstancedStruct<FItemInstance>& Item, TArray<TInstancedStruct<FAffixInstance>>& OutAffixes, bool bIncludeSocketedItems /*= true*/)
+{
+	const FItemInstance* ItemInstance = Item.GetPtr();
+	if (!ItemInstance)
+	{
+		return false;
+	}
+
+	OutAffixes.Empty(ItemInstance->Affixes.Num());
+	OutAffixes.Append(ItemInstance->Affixes);
+
+	if (bIncludeSocketedItems)
+	{
+		for (const TInstancedStruct<FItemSocketInstance>& Socket : ItemInstance->Sockets)
+		{
+			const FItemSocketInstance* SocketInstance = Socket.GetPtr();
+			if (SocketInstance && !SocketInstance->bIsEmpty)
+			{
+				const FItemInstance* SocketedItemInstance = SocketInstance->GetSocketedItem().GetPtr<const FItemInstance>();
+				if (SocketedItemInstance)
+				{
+					const TArray<TInstancedStruct<FAffixInstance>>& Affixes = SocketedItemInstance->Affixes;
+					for (const TInstancedStruct<FAffixInstance>& Affix : Affixes)
+					{
+						const FAffixInstance* AffixInstance = Affix.GetPtr();
+						if (AffixInstance)
+						{
+							const FAffixDefinition* AffixDefinition = AffixInstance->GetAffixDefinition().GetPtr();
+							if (AffixDefinition && AffixDefinition->bShouldAggregateInSockets)
+							{
+								OutAffixes.Add(Affix);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return OutAffixes.Num() > 0;
+}

Plugins/GenericItemization/Source/GenericItemization/Private/GenericItemizationTags.cpp

@@ -9,7 +9,10 @@ namespace GenericItemizationGameplayTags
 	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(AffixType, "Itemization.AffixType", "The overarching type of a particular Affix that creates logical groups of Affixes that might do the same/similar thing.");
 	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(UserData, "Itemization.UserData", "Arbitrary Data that can contain whatever you like.");
 	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(Mutator, "Itemization.Mutator", "Arbitrary Data that can contain whatever you like that is appended to the ItemInstancingContext.");
+	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(SocketType, "Itemization.SocketType", "The overarching type of an ItemSocket.");
 
 	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(ItemInstanceChange, "Itemization.ItemInstanceChange", "Describes a change to an ItemInstance.");
-	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(StackCountChange, "Itemization.ItemInstanceChange.StackCount", "The StackCount of an ItemInstance was changed.");
+	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(ItemInstanceChange_StackCount, "Itemization.ItemInstanceChange.StackCount", "The StackCount of an ItemInstance was changed.");
+	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(ItemInstanceChange_SocketChange_Socketed, "Itemization.ItemInstanceChange.SocketChange.Socketed", "An ItemInstance was Socketed into another ItemInstance.");
+	GENERICITEMIZATION_API UE_DEFINE_GAMEPLAY_TAG_COMMENT(ItemInstanceChange_SocketChange_Unsocketed, "Itemization.ItemInstanceChange.SocketChange.Unsocketed", "An ItemInstance was Unsocketed from another ItemInstance.");
 }

Plugins/GenericItemization/Source/GenericItemization/Private/GenericItemizationTypes.cpp

@@ -3,6 +3,7 @@
 #include "GenericItemizationTypes.h"
 #include "GenericItemizationPickFunctions.h"
 #include "GenericItemizationInstancingFunctions.h"
+#include "GenericItemizationTags.h"
 
 FItemDropTableCollectionRow::FItemDropTableCollectionRow()
 {
@@ -19,6 +20,7 @@ FItemDefinitionCollection::FItemDefinitionCollection()
 FItemDefinition::FItemDefinition()
 {
 	InstancingFunction = UItemInstancingFunction::StaticClass();
+	SocketableInto.AddTag(GenericItemizationGameplayTags::SocketType);
 }
 
 bool FItemDefinition::IsSameItemDefinition(const FItemDefinition& Other) const