ProjectEleri/Source/ProjectEleri/Private/InventoryComponent.cpp

// Fill out your copyright notice in the Description page of Project Settings.


#include "InventoryComponent.h"

#include "MyCharacter.h"
#include "Kismet/GameplayStatics.h"
#include "../Items/ItemDatabase.h"
#include "ProjectEleri/Settings/EleriGameSettings.h"


// Sets default values for this component's properties
UInventoryComponent::UInventoryComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	PrimaryComponentTick.bCanEverTick = false;
	// ...
}


// Called when the game starts
void UInventoryComponent::BeginPlay()
{
	Super::BeginPlay();

	if (!GetOwner()->ActorHasTag(INVENTORY_TAG))
	{
		GetOwner()->Tags.Add(INVENTORY_TAG);
	}

	if (GetWorld())
		ItemDatabase = GetWorld()->GetGameInstance()->GetSubsystem<UItemDatabase>();

	AssignToCharacter(GetOwner());
	InitializeInventory();
}

int32 UInventoryComponent::HasItem(FPrimaryAssetId ItemId, bool HQ) const
{
	for (int32 i = 0; i < ItemList.Num(); i++)
	{
		if (ItemId == ItemList[i].ItemId &&
			HQ == ItemList[i].HQ)
		{
			return i;
		}
	}
	return -1;
}

int32 UInventoryComponent::ItemExists(FPrimaryAssetId ItemToCheck, bool IsHq)
{
	for (int32 i = 0; i < ItemList.Num(); i++)
	{
		if (ItemList[i].ItemId == ItemToCheck && ItemList[i].HQ == IsHq)
		{
			return i;
		}
	}
	return -1;
}

bool UInventoryComponent::AddItemToInventory(FPrimaryAssetId ItemToAdd, int32 StackSize, bool HighQuality)
{
	if (!ItemToAdd.IsValid()) return false;

	int32 itemIndex = ItemExists(ItemToAdd, HighQuality);
	if (itemIndex == -1)
	{
		FItemStack ItemStack;
		ItemStack.ItemId = ItemToAdd;
		ItemStack.Stack = StackSize;
		ItemStack.HQ = HighQuality;
		ItemList.Add(ItemStack);
	}
	else
	{
		ItemList[itemIndex].Stack += StackSize;
	}
	OnInventoryUpdated.Broadcast();

	return true;
}

bool UInventoryComponent::RemoveItemFromInventory(FPrimaryAssetId ItemId, int32 Amount, bool HighQuality)
{
	if (ItemId.IsValid())
	{
		int32 ItemIndex = ItemExists(ItemId, HighQuality);
		if (ItemIndex == -1)
		{
			return false;
		}
		else
		{
			if (Amount == ItemList[ItemIndex].Stack)
			{
				ItemList.RemoveAt(ItemIndex);
			}
			else
			{
				ItemList[ItemIndex].Stack -= Amount;
			}
			OnInventoryUpdated.Broadcast();
			return true;
		}
	}
	return false;
}


void UInventoryComponent::InitializeInventory()
{
	if (ItemDatabase)
	{
		for (FDefaultItemStack ItemData : DefaultItems)
		{
			if (IsValid(ItemData.Item))
			{
				AddItemToInventory(ItemData.Item->GetPrimaryAssetId(), ItemData.StackSize, ItemData.HQ);
			}
		}
	}
}

void UInventoryComponent::EmptyInventory()
{
	ItemStacks.Empty();
	ItemList.Empty();
	OnInventoryUpdated.Broadcast();
}

int32 UInventoryComponent::GetStackForItem(FPrimaryAssetId ItemId, bool HQ) const
{
	for (int32 i = 0; i < ItemList.Num(); i++)
	{
		if (ItemList[i].ItemId == ItemId && ItemList[i].HQ == HQ)
			return ItemList[i].Stack;
	}
	return 0;
}

TArray<FPrimaryAssetId> UInventoryComponent::GetItemAssetIds()
{
	TArray<FPrimaryAssetId> AllIds;
	for (int32 i = 0; i < ItemList.Num(); i++)
	{
		AllIds.Add(ItemList[i].ItemId);
	}
	return AllIds;
}

void UInventoryComponent::ChangeCapacity(int32 NewCapacity) {
	Capacity = NewCapacity;
}

FInventorySaveData UInventoryComponent::PrepareSaveData()
{
	FInventorySaveData StackData;
	StackData.ItemStacks = ItemList;
	return StackData;
}

void UInventoryComponent::LoadFromSave(const FInventorySaveData& LoadData)
{
	EmptyInventory();
	for (const FItemStack& SaveDataEntry : LoadData.ItemStacks)
	{
		AddItemToInventory(SaveDataEntry.ItemId, SaveDataEntry.Stack, SaveDataEntry.HQ);
	}
}


void UInventoryComponent::AssignToCharacter(AActor* Character)
{
	ActorAttachedTo = Character;
}