LuckyWorldV2/Source/Luckyrobots/Private/Core/LuckyRobotsGameInstance.cpp

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


#include "Core/LuckyRobotsGameInstance.h"
#include "GameModes/LuckyRobotsGameState.h"
#include "Kismet/GameplayStatics.h"
#include "UI/GameUserWidget.h"
#include "Kismet/KismetSystemLibrary.h"
#include "GameFramework/GameUserSettings.h"
#include "Kismet/KismetMathLibrary.h"
#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"

void ULuckyRobotsGameInstance::DoSendMessage(const FString& SendValue)
{
	if (ALuckyRobotsGameState* GameState = Cast<ALuckyRobotsGameState>(UGameplayStatics::GetGameState(this)))
	{
		GameState->DoSendMessage(SendValue);
	}
	DoLogItemAdd(TEXT("Receive"), SendValue, ELogItemType::Debug);
}

void ULuckyRobotsGameInstance::DoLogItemAdd(const FString& Topic, const FString& MsgText, ELogItemType LogItemType)
{
	if (GameUserWidget)
	{
		GameUserWidget->DoLogItemAdd(Topic, MsgText, LogItemType);
	}
}

void ULuckyRobotsGameInstance::SwitchGamePaused()
{
	bool bPaused = UGameplayStatics::IsGamePaused(this);
	UGameplayStatics::SetGamePaused(this, !bPaused);

	if (!bPaused)
	{
		UKismetSystemLibrary::ExecuteConsoleCommand(this, TEXT("r.SceneRendering 0"));
	}
	else
	{
		UKismetSystemLibrary::ExecuteConsoleCommand(this, TEXT("r.SceneRendering 1"));
	}
}

void ULuckyRobotsGameInstance::ClearTaskList()
{
	TaskList.Empty();
}

void ULuckyRobotsGameInstance::AddTask(const FGoalsTaskData& TaskData)
{
	TaskList.Add(TaskData);
}

void ULuckyRobotsGameInstance::RemoveTask(const FGoalsTaskData& TaskData)
{
	TaskList.Remove(TaskData);
}

void ULuckyRobotsGameInstance::RemoveTaskByGoalType(EGoalType GoalType)
{
	for (const FGoalsTaskData& Task : TaskList)
	{
		if (Task.GoalType == GoalType)
		{
			RemoveTask(Task);
			break;
		}
	}
}

int32 ULuckyRobotsGameInstance::GetTaskNum() const
{
	return TaskList.Num();
}

void ULuckyRobotsGameInstance::SetTask(int32 Index, const FGoalsTaskData& TaskData)
{
	if (TaskList.IsValidIndex(Index))
	{
		TaskList[Index] = TaskData;
	}
	else
	{
		while (TaskList.Num() < Index)
		{
			FGoalsTaskData TempTaskData;
			AddTask(TempTaskData);
		}
		AddTask(TaskData);
	}
}

bool ULuckyRobotsGameInstance::GetTask(int32 Index, FGoalsTaskData& OutTaskData) const
{
	if (TaskList.IsValidIndex(Index))
	{
		OutTaskData = TaskList[Index];
		return true;
	}
	return false;
}

void ULuckyRobotsGameInstance::ReSetTaskList()
{
	TArray<FGoalsTaskData> TempTaskList;
	for (FGoalsTaskData& Task : TaskList)
	{
		Task.bIsStart = false;
		Task.bIsComplete = false; 
		Task.bActive = false;
		TempTaskList.Add(Task);
	}
	TaskList = TempTaskList;
}

TArray<FGoalsTaskData> ULuckyRobotsGameInstance::GetTaskList() const
{
	return TaskList;
}

void ULuckyRobotsGameInstance::DoSetTempTaskValueChange(bool bIsClear)
{
	if (bIsClear)
	{
		ClearTaskList();
	}
	else
	{
		AddTask(TempTask);
	}

	if (GameUserWidget)
	{
		GameUserWidget->DoRefreshListView();
	}
}

void ULuckyRobotsGameInstance::DoResolutionChange(bool bIsFullscreen)
{
	UGameUserSettings* GameUserSettings = UGameUserSettings::GetGameUserSettings();
	if (!GameUserSettings)
	{
		return;
	}

	FIntPoint LastResolution = FIntPoint(1280, 720);
	if (bIsFullscreen)
	{
		TArray<FIntPoint> SupportedResolutions;
		if (UKismetSystemLibrary::GetSupportedFullscreenResolutions(SupportedResolutions))
		{
			if (SupportedResolutions.Num() > 0)
			{
				LastResolution = SupportedResolutions.Last();
			}
		}
	}
	else
	{
		FString PlatformName = UGameplayStatics::GetPlatformName();
		if(PlatformName == "Linux")
		{ 
			LastResolution = FIntPoint(720, 405);
		}
		else if (PlatformName == "Mac")
		{
			LastResolution = FIntPoint(720, 405);
		}
		else if(PlatformName == "Windows")
		{
			LastResolution = FIntPoint(1280, 720);
		}
	}
	GameUserSettings->SetScreenResolution(LastResolution);
	GameUserSettings->SetFullscreenMode(bIsFullscreen ? EWindowMode::Fullscreen : EWindowMode::Windowed);
	GameUserSettings->ApplyResolutionSettings(false);  

}

FString ULuckyRobotsGameInstance::DoRandomString(FString StartString)
{
	FString TempString = "";
	for (int32 Index = 0; Index < 7; Index++)
	{
		int32 RandomIndex = UKismetMathLibrary::RandomInteger(AlphabetForRandomList.Num());
		if (AlphabetForRandomList.IsValidIndex(RandomIndex))
		{
			TempString.Append(AlphabetForRandomList[RandomIndex]);
		}
	}

	return StartString + "#" + TempString;
}

void ULuckyRobotsGameInstance::UpdateQualitySettings()
{
	if (UGameUserSettings* GameUserSettings = GEngine->GetGameUserSettings())
	{
		GameUserSettings->SetOverallScalabilityLevel(static_cast<int32>(CurrentSelectQuality));
		GameUserSettings->SaveSettings();
		GameUserSettings->ApplySettings(true);
	}
}

void ULuckyRobotsGameInstance::DoQualitySettings(int32 Quality, bool Auto)
{
	if (Auto)
	{
		bIsFirstOpenGame = false;
	}
	else
	{
		UpdateQualitySettings();
	}
}

FString ULuckyRobotsGameInstance::GetWriteFolderPath()
{
	FString Directory = FPaths::ConvertRelativePathToFull(FPaths::ProjectDir());
	FString WriteFolderPath = FPaths::Combine(Directory, GetCurrentFolderName()) + "/";

	return WriteFolderPath;
}

TSoftObjectPtr<UStaticMesh> ULuckyRobotsGameInstance::GetRandomMesh()
{
	int32 MeshCount = GetCurrentRandomMeshes().Num();
	if (MeshCount > 0)
	{
		int32 RandomIndex = UKismetMathLibrary::RandomIntegerInRange(0, MeshCount - 1);
		if (GetCurrentRandomMeshes().IsValidIndex(RandomIndex))
		{
			return GetCurrentRandomMeshes()[RandomIndex];
		}
	}

	return nullptr;
}

TArray<FSelectableItemData> ULuckyRobotsGameInstance::GetSelectableItemList(EItemCategory ItemCategory)
{
	TArray<FSelectableItemData> SelectableItemList;
	UDataTable* SelectedDataTable = nullptr;

	switch (ItemCategory)
	{
	case EItemCategory::Furniture:
		SelectedDataTable = FurnitureDataTable;
		break;
	case EItemCategory::Decoration:
		SelectedDataTable = DecorationDataTable;
		break;
	case EItemCategory::Kitchenware:
		SelectedDataTable = KitchenwareDataTable;
		break;
	case EItemCategory::Electronics:
		SelectedDataTable = ElectronicsDataTable;
		break;
	case EItemCategory::Bathroom:
		SelectedDataTable = BathroomDataTable;
		break;
	default:
		break;
	}

	if (SelectedDataTable)
	{
		FString ContextString;
		TArray<FName> RowNames = SelectedDataTable->GetRowNames();
		for (const FName& RowName : RowNames)
		{
			FSelectableItemData* ItemData = SelectedDataTable->FindRow<FSelectableItemData>(RowName, ContextString);
			if (ItemData)
			{
				if (ItemData->Category == ItemCategory && UKismetSystemLibrary::IsValidSoftObjectReference(ItemData->Mesh))
				{
					SelectableItemList.Add(*ItemData);
				}
			}
		}
	}

	return SelectableItemList;
}

void ULuckyRobotsGameInstance::SetCurrentFolderName(const FString& FolderName)
{
	CurrentCaptureSettingsData.FolderName = FText::FromString(FolderName);
}

void ULuckyRobotsGameInstance::SetCurrentFileName(const FString& FileName)
{
	CurrentCaptureSettingsData.FileName = FText::FromString(FileName);
}

void ULuckyRobotsGameInstance::SetCurrentWritesPerSec(int32 WritesPerSec)
{
	CurrentCaptureSettingsData.WritesPerSec = FText::FromString(FString::FromInt(WritesPerSec));
}

void ULuckyRobotsGameInstance::SetCurrentIsScenario(bool IsScenario)
{
	CurrentCaptureSettingsData.IsScenario = IsScenario;
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomLight(bool bLight)
{
	CurrentCaptureSettingsData.bLight = bLight;
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomMaterials(bool bMaterials)
{
	CurrentCaptureSettingsData.bMaterials = bMaterials;
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomRobotPosition(bool bRobotPosition)
{
	CurrentCaptureSettingsData.bRobotPosition = bRobotPosition;
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomPets(bool bPets)
{
	CurrentCaptureSettingsData.bPets = bPets;
}

void ULuckyRobotsGameInstance::SetCurrentPetsNumber(int32 PetsNumber)
{
	CurrentCaptureSettingsData.NumberOfPets = FText::FromString(FString::FromInt(PetsNumber));
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomPeople(bool bPeople)
{
	CurrentCaptureSettingsData.bPeople = bPeople;
}

void ULuckyRobotsGameInstance::SetCurrentPeopleNumber(int32 PeopleNumber)
{
	CurrentCaptureSettingsData.NumberOfPeople = FText::FromString(FString::FromInt(PeopleNumber));
}

void ULuckyRobotsGameInstance::SetCurrentIsRandomObjects(bool bObjects)
{
	CurrentCaptureSettingsData.bObjects = bObjects;
}

void ULuckyRobotsGameInstance::SetCurrentObjectsNumber(int32 ObjectsNumber)
{
	CurrentCaptureSettingsData.NumberOfObjects = FText::FromString(FString::FromInt(ObjectsNumber));
}

void ULuckyRobotsGameInstance::SetCurrentRandomMeshes(const TArray<TSoftObjectPtr<UStaticMesh>>& RandomMeshes)
{
	CurrentCaptureSettingsData.RandomMeshes = RandomMeshes;
}

void ULuckyRobotsGameInstance::SetCurrentIsInfiniteCapture(bool bInfiniteCapture)
{
	CurrentCaptureSettingsData.bInfiniteCapture = bInfiniteCapture;
}

void ULuckyRobotsGameInstance::SetCurrentCaptureNumber(int32 CaptureNumber)
{
	CurrentCaptureSettingsData.NumberOfCaptures = FText::FromString(FString::FromInt(CaptureNumber));
}

FString ULuckyRobotsGameInstance::GetCurrentFolderName() const
{
	return CurrentCaptureSettingsData.FolderName.ToString();
}

FString ULuckyRobotsGameInstance::GetCurrentFileName() const
{
	return CurrentCaptureSettingsData.FileName.ToString();
}

int32 ULuckyRobotsGameInstance::GetCurrentWritesPerSec() const
{
	return FCString::Atoi(*CurrentCaptureSettingsData.WritesPerSec.ToString());
}

bool ULuckyRobotsGameInstance::GetCurrentIsScenario() const
{
	return CurrentCaptureSettingsData.IsScenario;
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomLight() const
{
	return CurrentCaptureSettingsData.bLight;
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomMaterials() const
{
	return CurrentCaptureSettingsData.bMaterials;
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomRobotPosition() const
{
	return CurrentCaptureSettingsData.bRobotPosition;
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomPets() const
{
	return CurrentCaptureSettingsData.bPets;
}

int32 ULuckyRobotsGameInstance::GetCurrentPetsNumber() const
{
	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfPets.ToString());
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomPeople() const
{
	return CurrentCaptureSettingsData.bPeople;
}

int32 ULuckyRobotsGameInstance::GetCurrentPeopleNumber() const
{
	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfPeople.ToString());
}

bool ULuckyRobotsGameInstance::GetCurrentIsRandomObjects() const
{
	return CurrentCaptureSettingsData.bObjects;
}

int32 ULuckyRobotsGameInstance::GetCurrentObjectsNumber() const
{
	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfObjects.ToString());
}

TArray<TSoftObjectPtr<UStaticMesh>> ULuckyRobotsGameInstance::GetCurrentRandomMeshes() const
{
	return CurrentCaptureSettingsData.RandomMeshes;
}

bool ULuckyRobotsGameInstance::GetCurrentIsInfiniteCapture() const
{
	return CurrentCaptureSettingsData.bInfiniteCapture;
}

int32 ULuckyRobotsGameInstance::GetCurrentCaptureNumber() const
{
	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfCaptures.ToString());
}

void ULuckyRobotsGameInstance::SetWidgetTotalHit(int32 Value)
{
	WidgetTotalHit = Value;
}

int32 ULuckyRobotsGameInstance::GetWidgetTotalHit() const
{
	return WidgetTotalHit;
}