Source/Luckyrobots/Private/CaptureSettingsUserWidget.cpp

@@ -1,5 +1,5 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "UI/Settings/CaptureSettingsUserWidget.h"
+#include "CaptureSettingsUserWidget.h"
 

Source/Luckyrobots/Private/FunctionLibraries/LuckyRobotsFunctionLibrary.cpp

@@ -1,125 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"
-#include "Core/LuckyRobotsGameInstance.h"
-#include "GameFramework/GameUserSettings.h"
-#include "Kismet/GameplayStatics.h"
-#include "Settings/SG_CaptureSetting.h"
-
-ULuckyRobotsGameInstance* ULuckyRobotsFunctionLibrary::GetLuckyRobotsGameInstance(const UObject* WorldContextObject)
-{
-	if (WorldContextObject && WorldContextObject->GetWorld())
-	{
-		return Cast<ULuckyRobotsGameInstance>(WorldContextObject->GetWorld()->GetGameInstance());
-	}
-	return nullptr;
-}
-
-TArray<FRobotData> ULuckyRobotsFunctionLibrary::GetActiveRobotDataList(const UObject* WorldContextObject)
-{
-	TArray<FRobotData> RobotDataList;
-	if (ULuckyRobotsGameInstance* GameInstance = GetLuckyRobotsGameInstance(WorldContextObject))
-	{
-		if (GameInstance->RobotDataDataTable)
-		{
-			FString ContextString;
-			TArray<FName> RowNames = GameInstance->RobotDataDataTable->GetRowNames();
-			for (const FName& RowName : RowNames)
-			{
-				FRobotData* pRow = GameInstance->RobotDataDataTable->FindRow<FRobotData>(RowName, ContextString);
-				if (pRow && pRow->bActive)
-				{
-					RobotDataList.Add(*pRow);
-				}
-			}
-		}
-	}
-	return RobotDataList;
-}
-
-TArray<FLevelData> ULuckyRobotsFunctionLibrary::GetActiveLevelDataList(const UObject* WorldContextObject)
-{
-	TArray<FLevelData> LevelDataList;
-	if (ULuckyRobotsGameInstance* GameInstance = GetLuckyRobotsGameInstance(WorldContextObject))
-	{
-		if (GameInstance->LevelDataTable)
-		{
-			FString ContextString;
-			TArray<FName> RowNames = GameInstance->LevelDataTable->GetRowNames();
-			for (const FName& RowName : RowNames)
-			{
-				FLevelData* pRow = GameInstance->LevelDataTable->FindRow<FLevelData>(RowName, ContextString);
-				if (pRow && pRow->bActive)
-				{
-					LevelDataList.Add(*pRow);
-				}
-			}
-		}
-	}
-	return LevelDataList;
-}
-
-void ULuckyRobotsFunctionLibrary::UpdateQualitySettings(const UObject* WorldContextObject)
-{
-	if (ULuckyRobotsGameInstance* GameInstance = GetLuckyRobotsGameInstance(WorldContextObject))
-	{
-		if (UGameUserSettings* GameUserSettings = GEngine->GetGameUserSettings())
-		{
-			GameUserSettings->SetOverallScalabilityLevel(static_cast<int32>(GameInstance->CurrentSelectQuality));
-			GameUserSettings->SaveSettings();
-			GameUserSettings->ApplySettings(true);
-		}
-	}
-}
-
-FCaptureSettingsData ULuckyRobotsFunctionLibrary::LoadCaptureSettings(const UObject* WorldContextObject)
-{
-	FCaptureSettingsData DefaultCaptureSetting;
-	DefaultCaptureSetting.FolderName = FText::FromString("robotdata");
-	DefaultCaptureSetting.FileName = FText::FromString("FILE");
-	DefaultCaptureSetting.WritesPerSec = FText::FromString("1");
-	DefaultCaptureSetting.NumberOfPeople = FText::FromString("1");
-	DefaultCaptureSetting.NumberOfObjects = FText::FromString("1");
-	DefaultCaptureSetting.NumberOfCaptures = FText::FromString("1");
-
-	USG_CaptureSetting* SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::LoadGameFromSlot("SGCaptureSettings", 0));
-	if (SaveGame)
-	{
-		if (ULuckyRobotsGameInstance* GameInstance = GetLuckyRobotsGameInstance(WorldContextObject))
-		{
-			GameInstance->CurrentCaptureSettingsData = SaveGame->CaptureSetting;
-		}
-		return SaveGame->CaptureSetting;
-	}
-	else
-	{
-		SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::CreateSaveGameObject(USG_CaptureSetting::StaticClass()));
-		if (SaveGame)
-		{
-			SaveGame->CaptureSetting = DefaultCaptureSetting;
-			UGameplayStatics::SaveGameToSlot(SaveGame, "SGCaptureSettings", 0);
-		}
-	}
-
-	return DefaultCaptureSetting;
-}
-
-void ULuckyRobotsFunctionLibrary::SaveCaptureSettings(const UObject* WorldContextObject, FCaptureSettingsData CaptureSetting)
-{
-	if (ULuckyRobotsGameInstance* GameInstance = GetLuckyRobotsGameInstance(WorldContextObject))
-	{
-		GameInstance->CurrentCaptureSettingsData = CaptureSetting;
-	}
-
-	USG_CaptureSetting* SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::LoadGameFromSlot("SGCaptureSettings", 0));
-	if (!SaveGame)
-	{
-		SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::CreateSaveGameObject(USG_CaptureSetting::StaticClass()));
-	}
-	if (SaveGame)
-	{
-		SaveGame->CaptureSetting = CaptureSetting;
-		UGameplayStatics::SaveGameToSlot(SaveGame, "SGCaptureSettings", 0);
-	}
-}

Source/Luckyrobots/Private/GameUserWidget.cpp

@@ -0,0 +1,17 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "GameUserWidget.h"
+#include "LuckyRobotsFunctionLibrary.h"
+#include "LuckyRobotsGameInstance.h"
+
+void UGameUserWidget::NativeConstruct()
+{
+	Super::NativeConstruct();
+
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = ULuckyRobotsFunctionLibrary::GetLuckyRobotsGameInstance(this);
+	if (LuckyRobotsGameInstance)
+	{
+		LuckyRobotsGameInstance->GameUserWidget = this;
+	}
+}

Source/Luckyrobots/Private/LobbyGameMode.cpp

@@ -1,8 +1,8 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Lobby/LobbyGameMode.h"
-#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"
+#include "LobbyGameMode.h"
+#include "LuckyRobotsFunctionLibrary.h"
 
 void ALobbyGameMode::BeginPlay()
 {

Source/Luckyrobots/Private/LobbyPlayerController.cpp

@@ -1,7 +1,7 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Lobby/LobbyPlayerController.h"
+#include "LobbyPlayerController.h"
 
 void ALobbyPlayerController::BeginPlay()
 {

Source/Luckyrobots/Private/LuckyRobotsFunctionLibrary.cpp

@@ -0,0 +1,137 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "LuckyRobotsFunctionLibrary.h"
+#include "LuckyRobotsGameInstance.h"
+#include "GameFramework/GameUserSettings.h"
+#include "Kismet/GameplayStatics.h"
+#include "SG_CaptureSetting.h"
+
+ULuckyRobotsGameInstance* ULuckyRobotsFunctionLibrary::GetLuckyRobotsGameInstance(const UObject* WorldContextObject)
+{
+	return Cast<ULuckyRobotsGameInstance>(WorldContextObject->GetWorld()->GetGameInstance());
+}
+
+TArray<FRobotData> ULuckyRobotsFunctionLibrary::GetActiveRobotDataList(const UObject* WorldContextObject)
+{
+	TArray<FRobotData> RobotDataList;
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = GetLuckyRobotsGameInstance(WorldContextObject);
+	if (LuckyRobotsGameInstance)
+	{
+		if (LuckyRobotsGameInstance->RobotDataDataTable)
+		{
+			FString ContextString;
+			TArray<FName> RowNames = LuckyRobotsGameInstance->RobotDataDataTable->GetRowNames();
+			for (auto RowString : RowNames)
+			{
+				FRobotData* pRow = LuckyRobotsGameInstance->RobotDataDataTable->FindRow<FRobotData>(FName(RowString), ContextString);
+				if (pRow)
+				{
+					if (pRow->bActive)
+					{
+						RobotDataList.Add(*pRow);
+					}
+				}
+			}
+		}
+	}
+	return RobotDataList;
+}
+
+TArray<FLevelData> ULuckyRobotsFunctionLibrary::GetActiveLevelDataList(const UObject* WorldContextObject)
+{
+	TArray<FLevelData> LevelDataList;
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = GetLuckyRobotsGameInstance(WorldContextObject);
+	if (LuckyRobotsGameInstance)
+	{
+		if (LuckyRobotsGameInstance->LevelDataTable)
+		{
+			FString ContextString;
+			TArray<FName> RowNames = LuckyRobotsGameInstance->LevelDataTable->GetRowNames();
+			for (auto RowString : RowNames)
+			{
+				FLevelData* pRow = LuckyRobotsGameInstance->LevelDataTable->FindRow<FLevelData>(FName(RowString), ContextString);
+				if (pRow)
+				{
+					if (pRow->bActive)
+					{
+						LevelDataList.Add(*pRow);
+					}
+				}
+			}
+		}
+	}
+	return LevelDataList;
+}
+
+void ULuckyRobotsFunctionLibrary::UpdateQualitySettings(const UObject* WorldContextObject)
+{
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = GetLuckyRobotsGameInstance(WorldContextObject);
+	if (LuckyRobotsGameInstance)
+	{
+		// Load game user settings and apply
+		UGameUserSettings* GameUserSettings = GEngine->GetGameUserSettings();
+		if (GameUserSettings)
+		{
+			GameUserSettings->SetOverallScalabilityLevel(int(LuckyRobotsGameInstance->CurrentSelectQuality));
+			GameUserSettings->SaveSettings();
+			GameUserSettings->ApplySettings(true);
+		}
+	}
+}
+
+FCaptureSettingsData ULuckyRobotsFunctionLibrary::LoadCaptureSettings(const UObject* WorldContextObject)
+{
+	FCaptureSettingsData DefaultCaptureSetting;
+	DefaultCaptureSetting.FolderName = FText::FromString("robotdata");
+	DefaultCaptureSetting.FileName = FText::FromString("FILE");
+	DefaultCaptureSetting.WritesPerSec = FText::FromString("1");
+	DefaultCaptureSetting.NumberOfPeople = FText::FromString("1");
+	DefaultCaptureSetting.NumberOfObjects = FText::FromString("1");
+	DefaultCaptureSetting.NumberOfCaptures = FText::FromString("1");
+
+	USG_CaptureSetting* SaveGame = nullptr;
+	SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::LoadGameFromSlot("SGCaptureSettings", 0));
+	if (SaveGame)
+	{
+		ULuckyRobotsGameInstance* LuckyRobotsGameInstance = GetLuckyRobotsGameInstance(WorldContextObject);
+		if (LuckyRobotsGameInstance)
+		{
+			LuckyRobotsGameInstance->CurrentCaptureSettingsData = SaveGame->CaptureSetting;
+		}
+		return SaveGame->CaptureSetting;
+	}
+	else
+	{
+		SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::CreateSaveGameObject(USG_CaptureSetting::StaticClass()));
+		if (SaveGame)
+		{
+			SaveGame->CaptureSetting = DefaultCaptureSetting;
+			UGameplayStatics::SaveGameToSlot(SaveGame, "SGCaptureSettings", 0);
+		}
+	}
+
+	return DefaultCaptureSetting;
+}
+
+void ULuckyRobotsFunctionLibrary::SaveCaptureSettings(const UObject* WorldContextObject, FCaptureSettingsData CaptureSetting)
+{
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = GetLuckyRobotsGameInstance(WorldContextObject);
+	if (LuckyRobotsGameInstance)
+	{
+		LuckyRobotsGameInstance->CurrentCaptureSettingsData = CaptureSetting;
+	}
+
+	USG_CaptureSetting* SaveGame = nullptr;
+	SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::LoadGameFromSlot("SGCaptureSettings", 0));
+	if (!SaveGame)
+	{
+		SaveGame = Cast<USG_CaptureSetting>(UGameplayStatics::CreateSaveGameObject(USG_CaptureSetting::StaticClass()));
+	}
+
+	if (SaveGame)
+	{
+		SaveGame->CaptureSetting = CaptureSetting;
+		UGameplayStatics::SaveGameToSlot(SaveGame, "SGCaptureSettings", 0);
+	}
+}

Source/Luckyrobots/Private/LuckyRobotsGameInstance.cpp

@@ -1,22 +1,23 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Core/LuckyRobotsGameInstance.h"
-#include "GameModes/LuckyRobotsGameState.h"
+#include "LuckyRobotsGameInstance.h"
+#include "LuckyRobotsGameState.h"
 #include "Kismet/GameplayStatics.h"
-#include "UI/GameUserWidget.h"
-#include "Kismet/KismetSystemLibrary.h"
+#include "GameUserWidget.h"
 
-void ULuckyRobotsGameInstance::DoSendMessage(const FString& SendValue)
+void ULuckyRobotsGameInstance::DoSendMessage(FString SendValue)
 {
-	if (ALuckyRobotsGameState* GameState = Cast<ALuckyRobotsGameState>(UGameplayStatics::GetGameState(this)))
+	ALuckyRobotsGameState* LuckyRobotsGameState = Cast<ALuckyRobotsGameState>(UGameplayStatics::GetGameState(this));
+	if (LuckyRobotsGameState)
 	{
-		GameState->DoSendMessage(SendValue);
+		LuckyRobotsGameState->DoSendMessage(SendValue);
 	}
-	DoLogItemAdd(TEXT("Receive"), SendValue, ELogItemType::Debug);
+
+	DoLogItemAdd("Receive", SendValue, ELogItemType::Debug);
 }
 
-void ULuckyRobotsGameInstance::DoLogItemAdd(const FString& Topic, const FString& MsgText, ELogItemType LogItemType)
+void ULuckyRobotsGameInstance::DoLogItemAdd(FString Topic, FString MsgText, ELogItemType LogItemType)
 {
 	if (GameUserWidget)
 	{
@@ -26,16 +27,15 @@ void ULuckyRobotsGameInstance::DoLogItemAdd(const FString& Topic, const FString&
 
 void ULuckyRobotsGameInstance::SwitchGamePaused()
 {
-	bool bPaused = UGameplayStatics::IsGamePaused(this);
-	UGameplayStatics::SetGamePaused(this, !bPaused);
+	UGameplayStatics::SetGamePaused(this, !UGameplayStatics::IsGamePaused(this));
 
-	if (!bPaused)
+	if (UGameplayStatics::IsGamePaused(this))
 	{
-		UKismetSystemLibrary::ExecuteConsoleCommand(this, TEXT("r.SceneRendering 0"));
+		UKismetSystemLibrary::ExecuteConsoleCommand(this, "r.SceneRendering 0");
 	}
 	else
 	{
-		UKismetSystemLibrary::ExecuteConsoleCommand(this, TEXT("r.SceneRendering 1"));
+		UKismetSystemLibrary::ExecuteConsoleCommand(this, "r.SceneRendering 1");
 	}
 }
 
@@ -44,19 +44,18 @@ void ULuckyRobotsGameInstance::ClearTaskList()
 	TaskList.Empty();
 }
 
-void ULuckyRobotsGameInstance::AddTask(const FGoalsTaskData& TaskData)
+void ULuckyRobotsGameInstance::AddTask(FGoalsTaskData TaskData)
 {
 	TaskList.Add(TaskData);
 }
-
-void ULuckyRobotsGameInstance::RemoveTask(const FGoalsTaskData& TaskData)
+void ULuckyRobotsGameInstance::RemoveTask(FGoalsTaskData TaskData)
 {
 	TaskList.Remove(TaskData);
 }
 
 void ULuckyRobotsGameInstance::RemoveTaskByGoalType(EGoalType GoalType)
 {
-	for (const FGoalsTaskData& Task : TaskList)
+	for (auto Task : TaskList)
 	{
 		if (Task.GoalType == GoalType)
 		{
@@ -66,12 +65,12 @@ void ULuckyRobotsGameInstance::RemoveTaskByGoalType(EGoalType GoalType)
 	}
 }
 
-int32 ULuckyRobotsGameInstance::GetTaskNum() const
+int ULuckyRobotsGameInstance::GetTaskNum()
 {
 	return TaskList.Num();
 }
 
-void ULuckyRobotsGameInstance::SetTask(int32 Index, const FGoalsTaskData& TaskData)
+void ULuckyRobotsGameInstance::SetTask(int Index, FGoalsTaskData TaskData)
 {
 	if (TaskList.IsValidIndex(Index))
 	{
@@ -79,7 +78,7 @@ void ULuckyRobotsGameInstance::SetTask(int32 Index, const FGoalsTaskData& TaskDa
 	}
 	else
 	{
-		while (TaskList.Num() < Index)
+		for (int i = TaskList.Num(); i < Index; i++)
 		{
 			FGoalsTaskData TempTaskData;
 			AddTask(TempTaskData);
@@ -88,37 +87,39 @@ void ULuckyRobotsGameInstance::SetTask(int32 Index, const FGoalsTaskData& TaskDa
 	}
 }
 
-bool ULuckyRobotsGameInstance::GetTask(int32 Index, FGoalsTaskData& OutTaskData) const
+bool ULuckyRobotsGameInstance::GetTask(int Index, FGoalsTaskData& TaskData)
 {
 	if (TaskList.IsValidIndex(Index))
 	{
-		OutTaskData = TaskList[Index];
+		TaskData = TaskList[Index];
 		return true;
 	}
+
 	return false;
 }
 
 void ULuckyRobotsGameInstance::ReSetTaskList()
 {
 	TArray<FGoalsTaskData> TempTaskList;
-	for (FGoalsTaskData& Task : TaskList)
+	for (auto Task : TaskList)
 	{
 		Task.bIsStart = false;
-		Task.bIsComplete = false; 
+		Task.bIsStart = false;
 		Task.bActive = false;
 		TempTaskList.Add(Task);
 	}
+
 	TaskList = TempTaskList;
 }
 
-TArray<FGoalsTaskData> ULuckyRobotsGameInstance::GetTaskList() const
+TArray<FGoalsTaskData> ULuckyRobotsGameInstance::GetTaskList()
 {
 	return TaskList;
 }
 
-void ULuckyRobotsGameInstance::DoSetTempTaskValueChange(bool bIsClear)
+void ULuckyRobotsGameInstance::DoSetTempTaskValueChange(bool IsClear)
 {
-	if (bIsClear)
+	if (IsClear)
 	{
 		ClearTaskList();
 	}
@@ -133,162 +134,133 @@ void ULuckyRobotsGameInstance::DoSetTempTaskValueChange(bool bIsClear)
 	}
 }
 
-void ULuckyRobotsGameInstance::SetCurrentFolderName(const FString& FolderName)
+
+void ULuckyRobotsGameInstance::SetCurrentFolderName(FString FolderName)
 {
 	CurrentCaptureSettingsData.FolderName = FText::FromString(FolderName);
 }
-
-void ULuckyRobotsGameInstance::SetCurrentFileName(const FString& FileName)
+void ULuckyRobotsGameInstance::SetCurrentFileName(FString FileName)
 {
 	CurrentCaptureSettingsData.FileName = FText::FromString(FileName);
 }
-
-void ULuckyRobotsGameInstance::SetCurrentWritesPerSec(int32 WritesPerSec)
+void ULuckyRobotsGameInstance::SetCurrentWritesPerSec(int 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)
+void ULuckyRobotsGameInstance::SetCurrentPetsNumber(int PetsNumber)
 {
 	CurrentCaptureSettingsData.NumberOfPets = FText::FromString(FString::FromInt(PetsNumber));
 }
-
 void ULuckyRobotsGameInstance::SetCurrentIsRandomPeople(bool bPeople)
 {
 	CurrentCaptureSettingsData.bPeople = bPeople;
 }
-
-void ULuckyRobotsGameInstance::SetCurrentPeopleNumber(int32 PeopleNumber)
+void ULuckyRobotsGameInstance::SetCurrentPeopleNumber(int PeopleNumber)
 {
 	CurrentCaptureSettingsData.NumberOfPeople = FText::FromString(FString::FromInt(PeopleNumber));
 }
-
 void ULuckyRobotsGameInstance::SetCurrentIsRandomObjects(bool bObjects)
 {
 	CurrentCaptureSettingsData.bObjects = bObjects;
 }
-
-void ULuckyRobotsGameInstance::SetCurrentObjectsNumber(int32 ObjectsNumber)
+void ULuckyRobotsGameInstance::SetCurrentObjectsNumber(int ObjectsNumber)
 {
 	CurrentCaptureSettingsData.NumberOfObjects = FText::FromString(FString::FromInt(ObjectsNumber));
 }
-
-void ULuckyRobotsGameInstance::SetCurrentRandomMeshes(const TArray<TSoftObjectPtr<UStaticMesh>>& RandomMeshes)
+void ULuckyRobotsGameInstance::SetCurrentRandomMeshes(TArray<TSoftObjectPtr<UStaticMeshComponent>> RandomMeshes)
 {
 	CurrentCaptureSettingsData.RandomMeshes = RandomMeshes;
 }
-
 void ULuckyRobotsGameInstance::SetCurrentIsInfiniteCapture(bool bInfiniteCapture)
 {
 	CurrentCaptureSettingsData.bInfiniteCapture = bInfiniteCapture;
 }
-
-void ULuckyRobotsGameInstance::SetCurrentCaptureNumber(int32 CaptureNumber)
+void ULuckyRobotsGameInstance::SetCurrentCaptureNumber(int CaptureNumber)
 {
 	CurrentCaptureSettingsData.NumberOfCaptures = FText::FromString(FString::FromInt(CaptureNumber));
 }
 
-FString ULuckyRobotsGameInstance::GetCurrentFolderName() const
+FString ULuckyRobotsGameInstance::GetCurrentFolderName()
 {
 	return CurrentCaptureSettingsData.FolderName.ToString();
 }
-
-FString ULuckyRobotsGameInstance::GetCurrentFileName() const
+FString ULuckyRobotsGameInstance::GetCurrentFileName()
 {
 	return CurrentCaptureSettingsData.FileName.ToString();
 }
-
-int32 ULuckyRobotsGameInstance::GetCurrentWritesPerSec() const
+int ULuckyRobotsGameInstance::GetCurrentWritesPerSec()
 {
-	return FCString::Atoi(*CurrentCaptureSettingsData.WritesPerSec.ToString());
+	return FCString::Atoi(*(CurrentCaptureSettingsData.WritesPerSec.ToString()));
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsScenario() const
+bool ULuckyRobotsGameInstance::GetCurrentIsScenario()
 {
 	return CurrentCaptureSettingsData.IsScenario;
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomLight() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomLight()
 {
 	return CurrentCaptureSettingsData.bLight;
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomMaterials() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomMaterials()
 {
 	return CurrentCaptureSettingsData.bMaterials;
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomRobotPosition() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomRobotPosition()
 {
 	return CurrentCaptureSettingsData.bRobotPosition;
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomPets() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomPets()
 {
 	return CurrentCaptureSettingsData.bPets;
 }
-
-int32 ULuckyRobotsGameInstance::GetCurrentPetsNumber() const
+int ULuckyRobotsGameInstance::GetCurrentPetsNumber()
 {
-	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfPets.ToString());
+	return FCString::Atoi(*(CurrentCaptureSettingsData.NumberOfPets.ToString()));
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomPeople() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomPeople()
 {
 	return CurrentCaptureSettingsData.bPeople;
 }
-
-int32 ULuckyRobotsGameInstance::GetCurrentPeopleNumber() const
+int ULuckyRobotsGameInstance::GetCurrentPeopleNumber()
 {
-	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfPeople.ToString());
+	return FCString::Atoi(*(CurrentCaptureSettingsData.NumberOfPeople.ToString()));
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsRandomObjects() const
+bool ULuckyRobotsGameInstance::GetCurrentIsRandomObjects()
 {
 	return CurrentCaptureSettingsData.bObjects;
 }
-
-int32 ULuckyRobotsGameInstance::GetCurrentObjectsNumber() const
+int ULuckyRobotsGameInstance::GetCurrentObjectsNumber()
 {
-	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfObjects.ToString());
+	return FCString::Atoi(*(CurrentCaptureSettingsData.NumberOfObjects.ToString()));
 }
-
-TArray<TSoftObjectPtr<UStaticMesh>> ULuckyRobotsGameInstance::GetCurrentRandomMeshes() const
+TArray<TSoftObjectPtr<UStaticMeshComponent>> ULuckyRobotsGameInstance::GetCurrentRandomMeshes()
 {
 	return CurrentCaptureSettingsData.RandomMeshes;
 }
-
-bool ULuckyRobotsGameInstance::GetCurrentIsInfiniteCapture() const
+bool ULuckyRobotsGameInstance::GetCurrentIsInfiniteCapture()
 {
 	return CurrentCaptureSettingsData.bInfiniteCapture;
 }
-
-int32 ULuckyRobotsGameInstance::GetCurrentCaptureNumber() const
+int ULuckyRobotsGameInstance::GetCurrentCaptureNumber()
 {
-	return FCString::Atoi(*CurrentCaptureSettingsData.NumberOfCaptures.ToString());
-}
+	return FCString::Atoi(*(CurrentCaptureSettingsData.NumberOfCaptures.ToString()));
+}

Source/Luckyrobots/Private/LuckyRobotsGameMode.cpp

@@ -1,13 +1,14 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "GameModes/LuckyRobotsGameMode.h"
-#include "Core/LuckyRobotsGameInstance.h"
-#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"
+#include "LuckyRobotsGameMode.h"
+#include "LuckyRobotsGameInstance.h"
+#include "LuckyRobotsFunctionLibrary.h"
 
 void ALuckyRobotsGameMode::BeginPlay()
 {
 	Super::BeginPlay();
+
 	ULuckyRobotsFunctionLibrary::UpdateQualitySettings(this);
 }
 
@@ -16,21 +17,24 @@ UClass* ALuckyRobotsGameMode::GetDefaultPawnClassForController_Implementation(AC
 	UClass* RobotClass = Super::GetDefaultPawnClassForController_Implementation(InController);
 
 	ERobotsName CurrentRobot = ERobotsName::None;
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance());
+	if (LuckyRobotsGameInstance)
 	{
-		CurrentRobot = GameInstance->CurrentSelectRobot;
+		CurrentRobot = LuckyRobotsGameInstance->CurrentSelectRobot;
 	}
 	if (CurrentRobot != ERobotsName::None)
 	{
 		TArray<FRobotData> ActiveRobotDataList = ULuckyRobotsFunctionLibrary::GetActiveRobotDataList(this);
-		for (const FRobotData& RobotData : ActiveRobotDataList)
+		for (auto ActiveRobotData : ActiveRobotDataList)
 		{
-			if (RobotData.Name == CurrentRobot)
+			if (ActiveRobotData.Name == CurrentRobot)
 			{
-				RobotClass = RobotData.RobotClass;
+				RobotClass = ActiveRobotData.RobotClass;
 				break;
 			}
 		}
 	}
+
 	return RobotClass;
 }
+

Source/Luckyrobots/Private/LuckyRobotsGameState.cpp

@@ -1,10 +1,10 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "GameModes/LuckyRobotsGameState.h"
+#include "LuckyRobotsGameState.h"
 #include "SocketIOClientComponent.h"
-#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"
-#include "Core/LuckyRobotsGameInstance.h"
+#include "LuckyRobotsFunctionLibrary.h"
+#include "LuckyRobotsGameInstance.h"
 
 ALuckyRobotsGameState::ALuckyRobotsGameState()
 {
@@ -14,6 +14,7 @@ ALuckyRobotsGameState::ALuckyRobotsGameState()
 void ALuckyRobotsGameState::BeginPlay()
 {
 	Super::BeginPlay();
+
 	if (SocketIOClientComponent)
 	{
 		SocketIOClientComponent->Connect(L"http://localhost:3000/");
@@ -22,25 +23,33 @@ void ALuckyRobotsGameState::BeginPlay()
 
 void ALuckyRobotsGameState::DoSendMessage(FString SendValue)
 {
-	if (SocketIOClientComponent && SocketIOClientComponent->bIsConnected)
+	if (SocketIOClientComponent)
 	{
-		USIOJsonValue* SIOJsonValue = USIOJsonValue::ConstructJsonValueString(this, SendValue);
-		SocketIOClientComponent->Emit(TEXT("message"), SIOJsonValue);
+		if (SocketIOClientComponent->bIsConnected)
+		{
+			USIOJsonValue* SIOJsonValue = USIOJsonValue::ConstructJsonValueString(this, SendValue);
+			SocketIOClientComponent->Emit("message", SIOJsonValue);
+		}
 	}
 }
 
+
 void ALuckyRobotsGameState::DoSocketOnConnect(FString SocketId, FString SessionId, bool IsReconnection)
 {
-	if (SocketIOClientComponent && SocketIOClientComponent->bIsConnected)
+	if (SocketIOClientComponent)
 	{
-		SocketIOClientComponent->BindEventToGenericEvent(TEXT("response"));
+		if (SocketIOClientComponent->bIsConnected)
+		{
+			SocketIOClientComponent->BindEventToGenericEvent("response");
+		}
 	}
 }
 
 void ALuckyRobotsGameState::DoSocketOnGenericEvent(FString EventName, USIOJsonValue* EventData)
 {
-	if (ULuckyRobotsGameInstance* GameInstance = ULuckyRobotsFunctionLibrary::GetLuckyRobotsGameInstance(this))
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = ULuckyRobotsFunctionLibrary::GetLuckyRobotsGameInstance(this);
+	if (LuckyRobotsGameInstance)
 	{
-		GameInstance->DoGetDispatch(EventName, EventData);
+		LuckyRobotsGameInstance->DoGetDispatch(EventName, EventData);
 	}
-}
+}

Source/Luckyrobots/Private/LuckyRobotsPlayerController.cpp

@@ -1,5 +1,5 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Controllers/LuckyRobotsPlayerController.h"
+#include "LuckyRobotsPlayerController.h"
 

Source/Luckyrobots/Private/MainScreenUserWidget.cpp

@@ -0,0 +1,149 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "MainScreenUserWidget.h"
+#include "Engine/DataTable.h"
+#include "LuckyRobotsGameInstance.h"
+#include "LuckyRobotsFunctionLibrary.h"
+
+void UMainScreenUserWidget::NativeConstruct()
+{
+	Super::NativeConstruct();
+
+	InitData();
+}
+
+void UMainScreenUserWidget::InitData()
+{
+	InitRobotData();
+	InitLevelData();
+
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance());
+	if (LuckyRobotsGameInstance)
+	{
+		iCurrentSelectQuality = int(LuckyRobotsGameInstance->CurrentSelectQuality);
+	}
+}
+
+void UMainScreenUserWidget::InitRobotData()
+{
+	RobotDataList = ULuckyRobotsFunctionLibrary::GetActiveRobotDataList(this);
+
+	iCurrentSelectRobot = 0;
+	UpdateSelectRobot();
+}
+
+void UMainScreenUserWidget::InitLevelData()
+{
+	LevelDataList = ULuckyRobotsFunctionLibrary::GetActiveLevelDataList(this);
+
+	FRobotData CurrentRobotData = GetCurrentRobotData();
+	if (CurrentRobotData.Name != ERobotsName::None)
+	{
+		TArray<FLevelData> ActiveLevelDataList = LevelDataList;
+
+		LevelDataList.Empty();
+		for (auto ActiveLevelData : ActiveLevelDataList)
+		{
+			if (ActiveLevelData.RobotTypeList.Find(CurrentRobotData.RobotType) >= 0)
+			{
+				LevelDataList.Add(ActiveLevelData);
+			}
+		}
+	}
+
+	iCurrentSelectLevel = 0;
+	UpdateSelectLevel();
+}
+
+FRobotData UMainScreenUserWidget::GetCurrentRobotData()
+{
+	FRobotData CurrentRobotData;
+	if (RobotDataList.IsValidIndex(iCurrentSelectRobot))
+	{
+		CurrentRobotData = RobotDataList[iCurrentSelectRobot];
+	}
+	return CurrentRobotData;
+}
+
+FLevelData UMainScreenUserWidget::GetCurrentLevelData()
+{
+	FLevelData CurrentLevelData;
+	if (LevelDataList.IsValidIndex(iCurrentSelectLevel))
+	{
+		CurrentLevelData = LevelDataList[iCurrentSelectLevel];
+	}
+	return CurrentLevelData;
+}
+
+void UMainScreenUserWidget::SelectNextRobot()
+{
+	iCurrentSelectRobot = FMath::Clamp(iCurrentSelectRobot + 1, 0, RobotDataList.Num() - 1);
+	UpdateSelectRobot();
+}
+
+void UMainScreenUserWidget::SelectPreviousRobot()
+{
+	iCurrentSelectRobot = FMath::Clamp(iCurrentSelectRobot - 1, 0, RobotDataList.Num() - 1);
+	UpdateSelectRobot();
+}
+
+void UMainScreenUserWidget::SelectNextLevel()
+{
+	iCurrentSelectLevel = FMath::Clamp(iCurrentSelectLevel + 1, 0, LevelDataList.Num() - 1);
+	UpdateSelectLevel();
+}
+
+void UMainScreenUserWidget::SelectPreviousLevel()
+{
+	iCurrentSelectLevel = FMath::Clamp(iCurrentSelectLevel - 1, 0, LevelDataList.Num() - 1);
+	UpdateSelectLevel();
+}
+
+void UMainScreenUserWidget::SelectNextQuality()
+{
+	UEnum* QualityEnum = StaticEnum<EQualityEnum>();
+	int QualityEnumNum = QualityEnum->NumEnums() - 1;
+	iCurrentSelectQuality = FMath::Clamp(iCurrentSelectQuality - 1, 0, QualityEnumNum - 1);
+
+	UpdateSelectQuality();
+}
+
+void UMainScreenUserWidget::SelectPreviousQuality()
+{
+	UEnum* QualityEnum = StaticEnum<EQualityEnum>();
+	int QualityEnumNum = QualityEnum->NumEnums() - 1;
+	iCurrentSelectQuality = FMath::Clamp(iCurrentSelectQuality + 1, 0, QualityEnumNum - 1);
+
+	UpdateSelectQuality();
+}
+
+void UMainScreenUserWidget::UpdateSelectRobot()
+{
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance());
+	if (LuckyRobotsGameInstance)
+	{
+		LuckyRobotsGameInstance->CurrentSelectRobot = GetCurrentRobotData().Name;
+	}
+	BPUpdateSelectRobot();
+	InitLevelData();
+}
+void UMainScreenUserWidget::UpdateSelectLevel()
+{
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance());
+	if (LuckyRobotsGameInstance)
+	{
+		LuckyRobotsGameInstance->CurrentSelectLevel = GetCurrentLevelData().LevelEnum;
+	}
+	BPUpdateSelectLevel();
+}
+
+void UMainScreenUserWidget::UpdateSelectQuality()
+{
+	ULuckyRobotsGameInstance* LuckyRobotsGameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance());
+	if (LuckyRobotsGameInstance)
+	{
+		LuckyRobotsGameInstance->CurrentSelectQuality = static_cast<EQualityEnum>(iCurrentSelectQuality);
+	}
+	BPUpdateSelectQuality();
+}

Source/Luckyrobots/Private/Menus/MainScreenUserWidget.cpp

@@ -1,137 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "Menus/MainScreenUserWidget.h"
-#include "Engine/DataTable.h"
-#include "Core/LuckyRobotsGameInstance.h"
-#include "FunctionLibraries/LuckyRobotsFunctionLibrary.h"
-
-void UMainScreenUserWidget::NativeConstruct()
-{
-	Super::NativeConstruct();
-	InitData();
-}
-
-void UMainScreenUserWidget::InitData()
-{
-	InitRobotData();
-	InitLevelData();
-
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
-	{
-		CurrentQualityIndex = static_cast<int32>(GameInstance->CurrentSelectQuality);
-	}
-}
-
-void UMainScreenUserWidget::InitRobotData()
-{
-	RobotDataList = ULuckyRobotsFunctionLibrary::GetActiveRobotDataList(this);
-	CurrentRobotIndex = 0;
-	UpdateSelectRobot();
-}
-
-void UMainScreenUserWidget::InitLevelData()
-{
-	LevelDataList = ULuckyRobotsFunctionLibrary::GetActiveLevelDataList(this);
-	FRobotData CurrentRobotData = GetCurrentRobotData();
-	if (CurrentRobotData.Name != ERobotsName::None)
-	{
-		TArray<FLevelData> FilteredLevels;
-		for (const FLevelData& LevelData : LevelDataList)
-		{
-			if (LevelData.RobotTypeList.Contains(CurrentRobotData.RobotType))
-			{
-				FilteredLevels.Add(LevelData);
-			}
-		}
-		LevelDataList = FilteredLevels;
-	}
-	CurrentLevelIndex = 0;
-	UpdateSelectLevel();
-}
-
-FRobotData UMainScreenUserWidget::GetCurrentRobotData() const
-{
-	if (RobotDataList.IsValidIndex(CurrentRobotIndex))
-	{
-		return RobotDataList[CurrentRobotIndex];
-	}
-	return FRobotData();
-}
-
-FLevelData UMainScreenUserWidget::GetCurrentLevelData() const
-{
-	if (LevelDataList.IsValidIndex(CurrentLevelIndex))
-	{
-		return LevelDataList[CurrentLevelIndex];
-	}
-	return FLevelData();
-}
-
-void UMainScreenUserWidget::SelectNextRobot()
-{
-	CurrentRobotIndex = FMath::Clamp(CurrentRobotIndex + 1, 0, RobotDataList.Num() - 1);
-	UpdateSelectRobot();
-}
-
-void UMainScreenUserWidget::SelectPreviousRobot()
-{
-	CurrentRobotIndex = FMath::Clamp(CurrentRobotIndex - 1, 0, RobotDataList.Num() - 1);
-	UpdateSelectRobot();
-}
-
-void UMainScreenUserWidget::SelectNextLevel()
-{
-	CurrentLevelIndex = FMath::Clamp(CurrentLevelIndex + 1, 0, LevelDataList.Num() - 1);
-	UpdateSelectLevel();
-}
-
-void UMainScreenUserWidget::SelectPreviousLevel()
-{
-	CurrentLevelIndex = FMath::Clamp(CurrentLevelIndex - 1, 0, LevelDataList.Num() - 1);
-	UpdateSelectLevel();
-}
-
-void UMainScreenUserWidget::SelectNextQuality()
-{
-	UEnum* QualityEnum = StaticEnum<EQualityEnum>();
-	int32 EnumCount = QualityEnum->NumEnums() - 1;
-	CurrentQualityIndex = FMath::Clamp(CurrentQualityIndex - 1, 0, EnumCount - 1);
-	UpdateSelectQuality();
-}
-
-void UMainScreenUserWidget::SelectPreviousQuality()
-{
-	UEnum* QualityEnum = StaticEnum<EQualityEnum>();
-	int32 EnumCount = QualityEnum->NumEnums() - 1;
-	CurrentQualityIndex = FMath::Clamp(CurrentQualityIndex + 1, 0, EnumCount - 1);
-	UpdateSelectQuality();
-}
-
-void UMainScreenUserWidget::UpdateSelectRobot()
-{
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
-	{
-		GameInstance->CurrentSelectRobot = GetCurrentRobotData().Name;
-	}
-	BPUpdateSelectRobot();
-	InitLevelData();
-}
-
-void UMainScreenUserWidget::UpdateSelectLevel()
-{
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
-	{
-		GameInstance->CurrentSelectLevel = GetCurrentLevelData().LevelEnum;
-	}
-	BPUpdateSelectLevel();
-}
-
-void UMainScreenUserWidget::UpdateSelectQuality()
-{
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
-	{
-		GameInstance->CurrentSelectQuality = static_cast<EQualityEnum>(CurrentQualityIndex);
-	}
-	BPUpdateSelectQuality();
-}

Source/Luckyrobots/Private/SG_CaptureSetting.cpp

@@ -1,4 +1,4 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Settings/SG_CaptureSetting.h"
+#include "SG_CaptureSetting.h"

Source/Luckyrobots/Private/UI/GameUserWidget.cpp

@@ -1,14 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-
-#include "UI/GameUserWidget.h"
-#include "Core/LuckyRobotsGameInstance.h"
-
-void UGameUserWidget::NativeConstruct()
-{
-	Super::NativeConstruct();
-	if (ULuckyRobotsGameInstance* GameInstance = Cast<ULuckyRobotsGameInstance>(GetGameInstance()))
-	{
-		GameInstance->GameUserWidget = this;
-	}
-}

Source/Luckyrobots/Public/GameUserWidget.h

@@ -16,7 +16,7 @@ class LUCKYROBOTS_API UGameUserWidget : public UUserWidget
 	GENERATED_BODY()
 
 protected:
-	virtual void NativeConstruct() override;
+	virtual void NativeConstruct();
 
 public:
 	UFUNCTION(BlueprintImplementableEvent)

Source/Luckyrobots/Public/LuckyRobotsGameInstance.h

@@ -24,23 +24,9 @@ public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
 	UDataTable* LevelDataTable;
 
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
-	UDataTable* FurnitureDataTable;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
-	UDataTable* DecorationDataTable;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
-	UDataTable* KitchenwareDataTable;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
-	UDataTable* ElectronicsDataTable;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
-	UDataTable* BathroomDataTable;
-
 public:
 	bool bIsFirstOpenGame;
+
 	bool bIsDebug;
 	bool bIsWidgetTestMode;
 	bool bIsShowPath;
@@ -62,10 +48,10 @@ public:
 	bool bIsMouseOpen;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Capture")
-	bool bIsChanged; 
+	bool bIschange;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Capture")
-	int32 FolderCount;
+	int FolderCount;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Capture")
 	FTransform TargetPosition;
@@ -104,10 +90,10 @@ public:
 
 public:
 	UFUNCTION(BlueprintCallable)
-	void DoSendMessage(const FString& SendValue);
+	void DoSendMessage(FString SendValue);
 
 	UFUNCTION(BlueprintCallable)
-	void DoLogItemAdd(const FString& Topic, const FString& MsgText, ELogItemType LogItemType);
+	void DoLogItemAdd(FString Topic, FString MsgText, ELogItemType LogItemType);
 
 	UFUNCTION(BlueprintCallable)
 	void SwitchGamePaused();
@@ -117,41 +103,41 @@ public:
 	void ClearTaskList();
 
 	UFUNCTION(BlueprintCallable)
-	void AddTask(const FGoalsTaskData& TaskData);
+	void AddTask(FGoalsTaskData TaskData);
 
 	UFUNCTION(BlueprintCallable)
-	void RemoveTask(const FGoalsTaskData& TaskData);
+	void RemoveTask(FGoalsTaskData TaskData);
 
 	UFUNCTION(BlueprintCallable)
 	void RemoveTaskByGoalType(EGoalType GoalType);
 
 	UFUNCTION(BlueprintPure)
-	int32 GetTaskNum() const;
+	int GetTaskNum();
 
 	UFUNCTION(BlueprintCallable)
-	void SetTask(int32 Index, const FGoalsTaskData& TaskData);
+	void SetTask(int Index, FGoalsTaskData TaskData);
 
 	UFUNCTION(BlueprintCallable)
-	bool GetTask(int32 Index, FGoalsTaskData& OutTaskData) const;
+	bool GetTask(int Index, FGoalsTaskData& TaskData);
 
 	UFUNCTION(BlueprintCallable)
 	void ReSetTaskList();
 
 	UFUNCTION(BlueprintPure)
-	TArray<FGoalsTaskData> GetTaskList() const;
+	TArray<FGoalsTaskData> GetTaskList();
 
 	UFUNCTION(BlueprintCallable)
-	void DoSetTempTaskValueChange(bool bIsClear);
+	void DoSetTempTaskValueChange(bool IsClear);
 
 public:
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentFolderName(const FString& FolderName);
+	void SetCurrentFolderName(FString FolderName);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentFileName(const FString& FileName);
+	void SetCurrentFileName(FString FileName);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentWritesPerSec(int32 WritesPerSec);
+	void SetCurrentWritesPerSec(int WritesPerSec);
 
 	UFUNCTION(BlueprintCallable)
 	void SetCurrentIsScenario(bool IsScenario);
@@ -169,77 +155,77 @@ public:
 	void SetCurrentIsRandomPets(bool bPets);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentPetsNumber(int32 PetsNumber);
+	void SetCurrentPetsNumber(int PetsNumber);
 
 	UFUNCTION(BlueprintCallable)
 	void SetCurrentIsRandomPeople(bool bPeople);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentPeopleNumber(int32 PeopleNumber);
+	void SetCurrentPeopleNumber(int PeopleNumber);
 
 	UFUNCTION(BlueprintCallable)
 	void SetCurrentIsRandomObjects(bool bObjects);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentObjectsNumber(int32 ObjectsNumber);
+	void SetCurrentObjectsNumber(int ObjectsNumber);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentRandomMeshes(const TArray<TSoftObjectPtr<UStaticMesh>>& RandomMeshes);
+	void SetCurrentRandomMeshes(TArray<TSoftObjectPtr<UStaticMeshComponent>> RandomMeshes);
 
 	UFUNCTION(BlueprintCallable)
 	void SetCurrentIsInfiniteCapture(bool bInfiniteCapture);
 
 	UFUNCTION(BlueprintCallable)
-	void SetCurrentCaptureNumber(int32 CaptureNumber);
+	void SetCurrentCaptureNumber(int CaptureNumber);
 
 public:
 	UFUNCTION(BlueprintPure)
-	FString GetCurrentFolderName() const;
+	FString GetCurrentFolderName();
 
 	UFUNCTION(BlueprintPure)
-	FString GetCurrentFileName() const;
+	FString GetCurrentFileName();
 
 	UFUNCTION(BlueprintPure)
-	int32 GetCurrentWritesPerSec() const;
+	int GetCurrentWritesPerSec();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsScenario() const;
+	bool GetCurrentIsScenario();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomLight() const;
+	bool GetCurrentIsRandomLight();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomMaterials() const;
+	bool GetCurrentIsRandomMaterials();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomRobotPosition() const;
+	bool GetCurrentIsRandomRobotPosition();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomPets() const;
+	bool GetCurrentIsRandomPets();
 
 	UFUNCTION(BlueprintPure)
-	int32 GetCurrentPetsNumber() const;
+	int GetCurrentPetsNumber();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomPeople() const;
+	bool GetCurrentIsRandomPeople();
 
 	UFUNCTION(BlueprintPure)
-	int32 GetCurrentPeopleNumber() const;
+	int GetCurrentPeopleNumber();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsRandomObjects() const;
+	bool GetCurrentIsRandomObjects();
 
 	UFUNCTION(BlueprintPure)
-	int32 GetCurrentObjectsNumber() const;
+	int GetCurrentObjectsNumber();
 
 	UFUNCTION(BlueprintPure)
-	TArray<TSoftObjectPtr<UStaticMesh>> GetCurrentRandomMeshes() const;
+	TArray<TSoftObjectPtr<UStaticMeshComponent>> GetCurrentRandomMeshes();
 
 	UFUNCTION(BlueprintPure)
-	bool GetCurrentIsInfiniteCapture() const;
+	bool GetCurrentIsInfiniteCapture();
 
 	UFUNCTION(BlueprintPure)
-	int32 GetCurrentCaptureNumber() const;
+	int GetCurrentCaptureNumber();
 
 public:
 	UFUNCTION(BlueprintImplementableEvent)

Source/Luckyrobots/Public/MainScreenUserWidget.h

@@ -1,3 +1,5 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
 #pragma once
 
 #include "CoreMinimal.h"
@@ -5,12 +7,16 @@
 #include "SharedDef.h"
 #include "MainScreenUserWidget.generated.h"
 
+class UDataTable;
+/**
+ * 
+ */
 UCLASS()
 class LUCKYROBOTS_API UMainScreenUserWidget : public UUserWidget
 {
 	GENERATED_BODY()
 protected:
-	virtual void NativeConstruct() override;
+	virtual void NativeConstruct();
 
 public:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
@@ -20,29 +26,24 @@ public:
 	TArray<FLevelData> LevelDataList;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 CurrentRobotIndex;
+	int iCurrentSelectRobot;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	int iCurrentSelectLevel;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 CurrentLevelIndex;
-
-	UPROPERTY(EditAnywhere, BlueprintReadWrite)
-	int32 CurrentQualityIndex;
+	int iCurrentSelectQuality;
 
 public:
 	UFUNCTION(BlueprintCallable)
 	void InitData();
-
 	UFUNCTION(BlueprintCallable)
 	void InitRobotData();
-
 	UFUNCTION(BlueprintCallable)
 	void InitLevelData();
-
 	UFUNCTION(BlueprintCallable)
-	FRobotData GetCurrentRobotData() const;
-
+	FRobotData GetCurrentRobotData();
 	UFUNCTION(BlueprintCallable)
-	FLevelData GetCurrentLevelData() const;
+	FLevelData GetCurrentLevelData();
 
 	UFUNCTION(BlueprintCallable)
 	void SelectNextRobot();