void AMyGameMode::RandomItemID(/*Input*/ EItemType ItemType, /*Output*/FST_ItemTypeAndID& Item)
{
	TArray<FST_ItemTypeAndID> Arr{};
	FST_ItemTypeAndID GetByRef;

	switch (ItemType)
	{
	case EItemType::E_None:
		{
			ItemType = EItemType::E_Weapon;
		}break;
	case EItemType::E_Weapon:
		{
			if (const UDataTable* ItemWeaponRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Weapon/DT_ItamWeapon")))
			{
				//ItemWeaponRowNames = DT_ItamWeaponRows->GetRowNames();
				for (auto& WeaponElemArray : ItemWeaponRowNames->GetRowNames())
				{
					if (const UDataTable* ItemWeaponFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Weapon/DT_ItamWeapon")) })
					{
						if (const FST_ItemWeapon * OutRow_Weapon{ ItemWeaponFindRow->FindRow<FST_ItemWeapon>(FName(WeaponElemArray), "") })
						{
							if (OutRow_Weapon)
							{
								//printf100s("ArraySize Old: %d", ArrSize);
								for (int i = 1; i <= OutRow_Weapon->ProbabalityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_Weapon;
									TempTypeAndID_Setter.ID = FName(WeaponElemArray);
									Arr.Add(TempTypeAndID_Setter);//Adding elements
								}
							}
						}
					}
				}
			}
		}break;

	//Spawn probability is the same for all acc items, we don't need to set and loop all items for probability, just directly looping all items and add to array
	case EItemType::E_Accessories:
		{
			if (const UDataTable* ItemAccRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/WeaponAcc/DT_ItemWeaponAcc")))
			{
				for (auto& AccElemArray : ItemAccRowNames->GetRowNames())
				{
					TempTypeAndID_Setter.Type = EItemType::E_Accessories;
					TempTypeAndID_Setter.ID = FName(AccElemArray);
					Arr.Add(TempTypeAndID_Setter);//Adding elements
				}
			}
		}break;

	case EItemType::E_Ammo:
		{
			if (const UDataTable* ItemAmmoRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Ammo/DT_ItemAmmo")))
			{
				for (auto& AmmoElemArray : ItemAmmoRowNames->GetRowNames())
				{
					if (const UDataTable* ItemAmmoFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Ammo/DT_ItemAmmo")) })
					{
						if (const FST_ItemAmmo * OutRow_Ammo{ ItemAmmoFindRow->FindRow<FST_ItemAmmo>(FName(AmmoElemArray), "") })
						{
							if (OutRow_Ammo)
							{
								for (int32 i = 1; i <= OutRow_Ammo->ProbabilityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_Ammo;
									TempTypeAndID_Setter.ID = FName(AmmoElemArray);
									Arr.Add(TempTypeAndID_Setter);//Adding elements

								}
							}
						}
					}
				}
			}
		}break;

	case EItemType::E_Health:
		{
			if (const UDataTable* ItemHealRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Cure/DT_ItemHealth")))
			{
				for (auto& HealthElemArray : ItemHealRowNames->GetRowNames())
				{
					if (const UDataTable* ItemHealFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Cure/DT_ItemHealth")) })
					{
						if (const FST_ItemHealth * OutRow_Health{ ItemHealFindRow->FindRow<FST_ItemHealth>(FName(HealthElemArray), "") })
						{
							if (OutRow_Health)
							{
								for (int32 i = 1; i <= OutRow_Health->ProbabilityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_Health;
									TempTypeAndID_Setter.ID = FName(HealthElemArray);
									Arr.Add(TempTypeAndID_Setter);//Adding elements
								}
							}
						}
					}
				}
			}
		}break;

	case EItemType::E_Boost:
	{
		if (const UDataTable* ItemBoostRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Cure/DT_ItemBoost")))
		{
			for (auto& BoostElemArray : ItemBoostRowNames->GetRowNames())
			{
				if (const UDataTable* DataTableRow_Boost{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Cure/DT_ItemBoost")) })
				{
					if (const FST_ItemBoost * OutRow_Boost{ DataTableRow_Boost->FindRow<FST_ItemBoost>(FName(BoostElemArray), "") })
					{
						if (OutRow_Boost)
						{
							for (int32 i = 1; i <= OutRow_Boost->ProbabilityPercent; i++)
							{
								TempTypeAndID_Setter.Type = EItemType::E_Boost;
								TempTypeAndID_Setter.ID = FName(BoostElemArray);
								Arr.Add(TempTypeAndID_Setter);//Adding elements
							}
						}
					}
				}
			}
		}
	}break;

	case EItemType::E_Helmet:
	{
		if (const UDataTable* ItemHelmetRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")))
		{
			for (auto& HelmetElemArray : ItemHelmetRowNames->GetRowNames())
			{
				if (const UDataTable* ItemHelmetFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")) })
				{
					if (const FST_ItemEquipment * OutRow_Helmet{ ItemHelmetFindRow->FindRow<FST_ItemEquipment>(FName(HelmetElemArray), "") })
					{
						if (OutRow_Helmet)
						{
							//Equipment data table has 3 different types, so we need to check each if valid type before adding
							if (OutRow_Helmet->Type == EItemType::E_Helmet) //checking to set the correct properties, equipment data table has 3 items
							{
								for (int32 i = 1; i <= OutRow_Helmet->ProbabalityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_Helmet;
									TempTypeAndID_Setter.ID = FName (HelmetElemArray);
									Arr.Add(TempTypeAndID_Setter);//adding elements
								}
							}
						}
					}
				}
			}
		}
	}break;

	case EItemType::E_Vest:
	{
		if (const UDataTable* ItemVestRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")))
		{
			for (auto& VestElemArray : ItemVestRowNames->GetRowNames())
			{
				if (const UDataTable* IremVestFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")) })
				{
					if (const FST_ItemEquipment * OutRow_Vest{ IremVestFindRow->FindRow<FST_ItemEquipment>(FName(VestElemArray), "") })
					{
						if (OutRow_Vest)
						{
							//Equipment data table has 3 different types, so we need to check each if valid type before adding
							if (OutRow_Vest->Type == EItemType::E_Vest)
							{
								for (int32 i = 1; i <= OutRow_Vest->ProbabalityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_Vest;
									TempTypeAndID_Setter.ID = FName (VestElemArray);
									Arr.Add(TempTypeAndID_Setter);//adding elements
								}
							}
						}
					}
				}
			}
		}
	}break;

	case EItemType::E_BackPack:
	{
		if (const UDataTable* ItemBackpackRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")))
		{
			for (auto& BackpackElemArray : ItemBackpackRowNames->GetRowNames())
			{
				if (const UDataTable* ItemBackpackFindRow{ LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Equipment/DT_ItemEquipment")) })
				{
					if (const FST_ItemEquipment * OutOutRow_Backpack{ ItemBackpackFindRow->FindRow<FST_ItemEquipment>(FName(BackpackElemArray), "") })
					{
						if (OutOutRow_Backpack)
						{
							//Equipment data table has 3 different types, Helmet, Vest, Backpack
							if (OutOutRow_Backpack->Type == EItemType::E_BackPack)
							{
								for (int32 i = 1; i <= OutOutRow_Backpack->ProbabalityPercent; i++)
								{
									TempTypeAndID_Setter.Type = EItemType::E_BackPack;
									TempTypeAndID_Setter.ID = FName (BackpackElemArray);
									Arr.Add(TempTypeAndID_Setter);//adding elements
								}
							}
						}
					}
				}
			}
		}
	}break;

	case EItemType::E_Fashion:
	{
		if (const UDataTable* ItemFashionRowNames = LoadObject<UDataTable>(GetWorld(), TEXT("/Game/DataTables/Items/Fashion/DT_ItemFashion")))
		{
			for (auto& FashionElemArray : ItemFashionRowNames->GetRowNames())
			{
				TempTypeAndID_Setter.ID = FashionElemArray;
				TempTypeAndID_Setter.Type = EItemType::E_Fashion;
				Arr.Add(TempTypeAndID_Setter);//Adding elements
			}
		}
	}break;

	case EItemType::E_Pan:
	{
		//Need to pan generating logic
		print100s("This is Pan Spawn Nulled"); return;
	}break;

	case EItemType::E_Grenade:
	{
		//Need to implement grenade generating logic
		print100s("This is Grenade Spawn Nulled"); return;
	}break;

	default:
		{
		return;
		}break;
	}

	GetByRef = Arr[FMath::RandRange(0, Arr.Num() - 1)];
	FCustomThunkTemplates::Array_Shuffle(Arr);
	Item = GetByRef;

}