LuckyWorldV2/Source/Luckyrobots/Public/SharedDef.h

#pragma once

#include "SharedDef.generated.h"

UENUM(BlueprintType)
enum class ERobotsCategories : uint8
{
	Wheeled             UMETA(DisplayName = "Wheeled Robots"),
	FourLegged          UMETA(DisplayName = "Four-Legged Robots"),
	TwoLegged           UMETA(DisplayName = "Two-Legged Robots"),
	Stationary          UMETA(DisplayName = "Stationary Robots"),
	IndoorFlying        UMETA(DisplayName = "Indoor Flying Robots"),
	SwimmingUnderwater  UMETA(DisplayName = "Swimming/Underwater Robots"),
	CrawlingModular     UMETA(DisplayName = "Crawling/Modular Robots"),
	Arm                 UMETA(DisplayName = "Arm-Robots"),
	OutdoorFlying       UMETA(DisplayName = "Outdoor Flying Robots")
};

UENUM(BlueprintType)
enum class ERobotsName : uint8
{
	None                UMETA(DisplayName = "None"),
	Luck_e              UMETA(DisplayName = "Luck-e"),
	Stretch             UMETA(DisplayName = "Stretch"),
	LuckyDrone          UMETA(DisplayName = "Lucky Drone"),
	DJIDrone            UMETA(DisplayName = "DJI Drone"),
	ArmLucky            UMETA(DisplayName = "Arm Lucky"),
	UnitreeG1           UMETA(DisplayName = "Unitree G1"),
	StretchRobotV1      UMETA(DisplayName = "Stretch Robot V1"),
	PandaArmRobot       UMETA(DisplayName = "Panda Arm Robot"),
	PuralinkRobot       UMETA(DisplayName = "Puralink Robot"),
	UnitreeGo2          UMETA(DisplayName = "Unitree Go 2"),
	RevoluteRobot       UMETA(DisplayName = "Revolute Robot"),
	BostonSpotRobot     UMETA(DisplayName = "Boston Spot Robot")
};

UENUM(BlueprintType)
enum class ELevelType : uint8
{
	Home                UMETA(DisplayName = "Home"),
	Office              UMETA(DisplayName = "Office"),
	Street              UMETA(DisplayName = "Street"),
	TestLevel           UMETA(DisplayName = "TestLevel")
};

UENUM(BlueprintType)
enum class ELevelEnum : uint8
{
	None                UMETA(DisplayName = "None"),
	TestLevel           UMETA(DisplayName = "Test Level"),
	Loft                UMETA(DisplayName = "Loft"),
	Rome                UMETA(DisplayName = "Rome"),
	Paris               UMETA(DisplayName = "Paris"),
	Marseille           UMETA(DisplayName = "Marseille"),
	Istanbul            UMETA(DisplayName = "Istanbul"),
	Office              UMETA(DisplayName = "Office"),
	BasicForest         UMETA(DisplayName = "Basic Forest"),
	NaturalForest       UMETA(DisplayName = "Natural Forest"),
	KitchenForArmRobot  UMETA(DisplayName = "Kitchen for Arm Robot"),
	PipeFabric          UMETA(DisplayName = "Pipe Fabric")
};

UENUM(BlueprintType)
enum class EQualityEnum : uint8
{
	Low                 UMETA(DisplayName = "Low"),
	Middle              UMETA(DisplayName = "Middle"),
	High                UMETA(DisplayName = "High"),
	Epic                UMETA(DisplayName = "Epic")
};

UENUM(BlueprintType)
enum class EGoalType : uint8
{
	GrabAndPull                    UMETA(DisplayName = "Grab and Pull"),
	GrabAndRotate                  UMETA(DisplayName = "Grab and Rotate"),
	GrabAndOpen                    UMETA(DisplayName = "Grab and Open"),
	PickAndPlace                   UMETA(DisplayName = "Pick and Place"),
	Pick                           UMETA(DisplayName = "Pick"),
	GrabAndInsert                  UMETA(DisplayName = "Grab and Insert"),
	Find                           UMETA(DisplayName = "Find"),
	Point                          UMETA(DisplayName = "Point"),
	PointWithLaserPointer          UMETA(DisplayName = "Point with Laser Pointer"),
	RotateHand                     UMETA(DisplayName = "Rotate Hand"),
	SliceDice                      UMETA(DisplayName = "Slice/Dice"),
	Wipe                           UMETA(DisplayName = "Wipe"),
	FoldUnfold                     UMETA(DisplayName = "Fold/Unfold"),
	ArrangeOrganize                UMETA(DisplayName = "Arrange/Organize"),
	PressButton                    UMETA(DisplayName = "Press Button"),
	PourDispense                   UMETA(DisplayName = "Pour/Dispense"),
	NavigateSimpleEnvironments     UMETA(DisplayName = "Navigate Simple Environments"),
	NavigateComplexTerrain         UMETA(DisplayName = "Navigate Complex Terrain"),
	ClimbStairsOrRamps             UMETA(DisplayName = "Climb Stairs or Ramps"),
	BalanceStabilize               UMETA(DisplayName = "Balance/Stabilize"),
	DockingAndCharging             UMETA(DisplayName = "Docking and Charging"),
	ChangeGripper                  UMETA(DisplayName = "Change Gripper"),
	Place                          UMETA(DisplayName = "Place")
};

UENUM(BlueprintType)
enum class ESaveDataType : uint8
{
	file                UMETA(DisplayName = "file"),
	webserver           UMETA(DisplayName = "webserver"),
	http                UMETA(DisplayName = "http"),
	debug               UMETA(DisplayName = "debug"),
	none                UMETA(DisplayName = "none")
};

UENUM(BlueprintType)
enum class ELogItemType : uint8
{
	Debug               UMETA(DisplayName = "Debug"),
	War                 UMETA(DisplayName = "War"),
	Error               UMETA(DisplayName = "Error"),
	Consol              UMETA(DisplayName = "Consol")
};

UENUM(BlueprintType)
enum class EFurniture : uint8
{
	None                    UMETA(DisplayName = "None"),
	Sofas                   UMETA(DisplayName = "Sofas"),
	Chairs                  UMETA(DisplayName = "Chairs"),
	Tables                  UMETA(DisplayName = "Tables"),
	Beds                    UMETA(DisplayName = "Beds"),
	Cabinets                UMETA(DisplayName = "Cabinets"),
	Shelves                 UMETA(DisplayName = "Shelves"),
	Desks                   UMETA(DisplayName = "Desks"),
	Doors                   UMETA(DisplayName = "Doors"),
	Drawers                 UMETA(DisplayName = "Drawers")
};

UENUM(BlueprintType)
enum class EDecoration : uint8
{
	None                  UMETA(DisplayName = "None"),
	Carpets               UMETA(DisplayName = "Carpets"),
	Paintings             UMETA(DisplayName = "Paintings"),
	Vases                 UMETA(DisplayName = "Vases"),
	Lamps                 UMETA(DisplayName = "Lamps"),
	Mirrors               UMETA(DisplayName = "Mirrors"),
	Curtains              UMETA(DisplayName = "Curtains"),
	Plants                UMETA(DisplayName = "Plants"),
	Textiles              UMETA(DisplayName = "Textiles"),
	Lighting              UMETA(DisplayName = "Lighting"),
	Outdoor               UMETA(DisplayName = "Outdoor"),
	OfficeSupplies        UMETA(DisplayName = "Office Supplies"),
	Books                 UMETA(DisplayName = "Books"),
	ToolsAndEquipment     UMETA(DisplayName = "Tools And Equipment"),
	Dressing              UMETA(DisplayName = "Dressing"),
	BasketsAndBoxes       UMETA(DisplayName = "Baskets And Boxes")
};

UENUM(BlueprintType)
enum class EKitchenware : uint8
{
	None                  UMETA(DisplayName = "None"),
	Plates                UMETA(DisplayName = "Plates"),
	Glasses               UMETA(DisplayName = "Glasses"),
	Cutlery               UMETA(DisplayName = "Cutlery"),
	Pots                  UMETA(DisplayName = "Pots"),
	SmallAppliances       UMETA(DisplayName = "Small Appliances"),
	Cups                  UMETA(DisplayName = "Cups"),
	Bottles               UMETA(DisplayName = "Bottles")
};

UENUM(BlueprintType)
enum class EElectronics : uint8
{
	None                  UMETA(DisplayName = "None"),
	Television            UMETA(DisplayName = "Television"),
	LargeAppliances       UMETA(DisplayName = "Large Appliances"),
	Oven                  UMETA(DisplayName = "Oven"),
	Computer              UMETA(DisplayName = "Computer"),
	KitchenGadgets        UMETA(DisplayName = "Kitchen Gadgets"),
	MusicGadgets          UMETA(DisplayName = "Music Gadgets"),
	SmallElectronics      UMETA(DisplayName = "Small Electronics")
};

UENUM(BlueprintType)
enum class EBathroom : uint8
{
	None                  UMETA(DisplayName = "None"),
	Towels                UMETA(DisplayName = "Towels"),
	SoapDispenser         UMETA(DisplayName = "Soap Dispenser"),
	ShowerCurtains        UMETA(DisplayName = "Shower Curtains"),
	BathMats              UMETA(DisplayName = "Bath Mats"),
	Toiletries            UMETA(DisplayName = "Toiletries")
};

UENUM(BlueprintType)
enum class EItemCategory : uint8
{
	Furniture             UMETA(DisplayName = "Furniture"),
	Decoration            UMETA(DisplayName = "Decoration"),
	Kitchenware           UMETA(DisplayName = "Kitchenware"),
	Electronics           UMETA(DisplayName = "Electronics"),
	Bathroom              UMETA(DisplayName = "Bathroom")
};

UENUM(BlueprintType)
enum class EHoldItemType : uint8
{
	None            UMETA(DisplayName = "None"),
	HoldObject      UMETA(DisplayName = "Hold Object"),
	DontTouch       UMETA(DisplayName = "Don't Touch")
};

UENUM(BlueprintType)
enum class EScenarioEnum : uint8
{
	None            UMETA(DisplayName = "None"),
	TidyUp          UMETA(DisplayName = "Tidy Up"),
	Draw            UMETA(DisplayName = "Draw"),
	StoveOff        UMETA(DisplayName = "Stove Off")
};

USTRUCT(BlueprintType)
struct FRobotData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	ERobotsName Name;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TSubclassOf<AActor> RobotClass;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FTransform Transform;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bActive;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	UTexture2D* RobotImage;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	ERobotsCategories RobotType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText HelpText;
};

USTRUCT(BlueprintType)
struct FLevelData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	int32 ID;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	ELevelEnum LevelEnum;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	ELevelType LevelType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TSoftObjectPtr<UWorld> LevelObject;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	UTexture2D* LevelImage;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bActive;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<ERobotsCategories> RobotTypeList;

	bool operator==(const FLevelData& Other) const
	{
		return ID == Other.ID &&
			LevelEnum == Other.LevelEnum &&
			LevelType == Other.LevelType &&
			LevelObject == Other.LevelObject &&
			LevelImage == Other.LevelImage &&
			bActive == Other.bActive &&
			RobotTypeList == Other.RobotTypeList;
	}

	FLevelData& operator=(const FLevelData& Other)
	{
		if (this != &Other)
		{
			ID = Other.ID;
			LevelEnum = Other.LevelEnum;
			LevelType = Other.LevelType;
			LevelObject = Other.LevelObject;
			LevelImage = Other.LevelImage;
			bActive = Other.bActive;
			RobotTypeList = Other.RobotTypeList;
		}
		return *this;
	}
};

USTRUCT(BlueprintType)
struct FGoalsTaskData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	EGoalType GoalType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bIsStart;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FTransform TargetLocation;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TSoftObjectPtr<UObject> TargetActor;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bIsComplete; 

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FVector DropOffLocation;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FString ObjectName;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bActive;

	bool operator==(const FGoalsTaskData& Other) const
	{
		return GoalType == Other.GoalType &&
			bIsStart == Other.bIsStart &&
			TargetLocation.Equals(Other.TargetLocation, 0.01f) &&
			TargetActor == Other.TargetActor &&
			bIsComplete == Other.bIsComplete &&
			DropOffLocation.Equals(Other.DropOffLocation, 0.01f) &&
			ObjectName == Other.ObjectName &&
			bActive == Other.bActive;
	}

	FGoalsTaskData& operator=(const FGoalsTaskData& Other)
	{
		if (this != &Other)
		{
			GoalType = Other.GoalType;
			bIsStart = Other.bIsStart;
			TargetLocation = Other.TargetLocation;
			TargetActor = Other.TargetActor;
			bIsComplete = Other.bIsComplete;
			DropOffLocation = Other.DropOffLocation;
			ObjectName = Other.ObjectName;
			bActive = Other.bActive;
		}
		return *this;
	}
};

USTRUCT(BlueprintType)
struct FCaptureSettingsData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText FolderName = FText::FromString("robotdata");

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText FileName = FText::FromString("FILE");

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText WritesPerSec = FText::FromString("1");

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool IsScenario;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<FGoalsTaskData> TaskList;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bLight;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bMaterials;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bRobotPosition;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bPets;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText NumberOfPets;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bPeople;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText NumberOfPeople = FText::FromString("1");

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bObjects;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText NumberOfObjects = FText::FromString("1");

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<TSoftObjectPtr<UStaticMesh>> RandomMeshes;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bInfiniteCapture;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FText NumberOfCaptures = FText::FromString("1");

	bool operator==(const FCaptureSettingsData& Other) const
	{
		return FolderName.EqualTo(Other.FolderName) &&
			FileName.EqualTo(Other.FileName) &&
			WritesPerSec.EqualTo(Other.WritesPerSec) &&
			IsScenario == Other.IsScenario &&
			TaskList == Other.TaskList &&
			bLight == Other.bLight &&
			bMaterials == Other.bMaterials &&
			bRobotPosition == Other.bRobotPosition &&
			bPets == Other.bPets &&
			NumberOfPets.EqualTo(Other.NumberOfPets) &&
			bPeople == Other.bPeople &&
			NumberOfPeople.EqualTo(Other.NumberOfPeople) &&
			bObjects == Other.bObjects &&
			NumberOfObjects.EqualTo(Other.NumberOfObjects) &&
			RandomMeshes == Other.RandomMeshes &&
			bInfiniteCapture == Other.bInfiniteCapture &&
			NumberOfCaptures.EqualTo(Other.NumberOfCaptures);
	}

	FCaptureSettingsData& operator=(const FCaptureSettingsData& Other)
	{
		if (this != &Other)
		{
			FolderName = Other.FolderName;
			FileName = Other.FileName;
			WritesPerSec = Other.WritesPerSec;
			IsScenario = Other.IsScenario;
			TaskList = Other.TaskList;
			bLight = Other.bLight;
			bMaterials = Other.bMaterials;
			bRobotPosition = Other.bRobotPosition;
			bPets = Other.bPets;
			NumberOfPets = Other.NumberOfPets;
			bPeople = Other.bPeople;
			NumberOfPeople = Other.NumberOfPeople;
			bObjects = Other.bObjects;
			NumberOfObjects = Other.NumberOfObjects;
			RandomMeshes = Other.RandomMeshes;
			bInfiniteCapture = Other.bInfiniteCapture;
			NumberOfCaptures = Other.NumberOfCaptures;
		}
		return *this;
	}
};

USTRUCT(BlueprintType)
struct FAllGoalListData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	EGoalType GoalType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FString Example;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TSubclassOf<UUserWidget> Widget;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bIsActive;
};

USTRUCT(BlueprintType)
struct FLuckyCode : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	int32 ID;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FString Code;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	float Time;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bCallback;
};

USTRUCT(BlueprintType)
struct FSelectableItemData : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	int32 ID;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	EItemCategory Category;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item", meta = (EditCondition = "Category == EItemCategory::Furniture", EditConditionHides))
	EFurniture FurnitureType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item", meta = (EditCondition = "Category == EItemCategory::Decoration", EditConditionHides))
	EDecoration DecorationType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item", meta = (EditCondition = "Category == EItemCategory::Kitchenware", EditConditionHides))
	EKitchenware KitchenwareType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item", meta = (EditCondition = "Category == EItemCategory::Electronics", EditConditionHides))
	EElectronics ElectronicsType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item", meta = (EditCondition = "Category == EItemCategory::Bathroom", EditConditionHides))
	EBathroom BathroomType;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FString Name;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	TSoftObjectPtr<UTexture2D> Icon;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	TSoftObjectPtr<UStaticMesh> Mesh;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FString Description;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	bool bIsStatic;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FTransform Transform;

	FSelectableItemData()
		: ID(0)
		, Category(EItemCategory::Furniture)
		, FurnitureType(EFurniture::None)
		, DecorationType(EDecoration::None)
		, KitchenwareType(EKitchenware::None)
		, ElectronicsType(EElectronics::None)
		, BathroomType(EBathroom::None)
		, Name(TEXT(""))
		, Icon(nullptr)
		, Mesh(nullptr)
		, Description(TEXT(""))
		, bIsStatic(false)
		, Transform(FTransform::Identity)
	{
	}
};

USTRUCT(BlueprintType)
struct FHoldItemStruct : public FTableRowBase
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	int32 ID;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FString Name;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	TSoftObjectPtr<UTexture2D> Icon;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	TSoftObjectPtr<UStaticMesh> Mesh;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FString Description;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	EHoldItemType Type;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	EScenarioEnum ScenarioEnum;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
	FTransform Transform;

	FHoldItemStruct()
		: ID(0)
		, Name(TEXT(""))
		, Icon(nullptr)
		, Mesh(nullptr)
		, Description(TEXT(""))
		, Type(EHoldItemType::None)
		, ScenarioEnum(EScenarioEnum::None)
		, Transform(FTransform::Identity)
	{
	}
};

USTRUCT(BlueprintType)
struct FStretchRobotActuator
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Actuator")
	FString Name;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Actuator")
	float Min;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Actuator")
	float Max;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Actuator")
	int32 Index;
};

USTRUCT(BlueprintType)
struct FRandomMaterialTexture
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<TSoftObjectPtr<UStaticMesh>> Meshs;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<TSoftObjectPtr<UMaterialInstance>> Materials;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	TArray<TSoftObjectPtr<UTexture>> Textures;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool RandomMaterial;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool RandomTexture;
};

USTRUCT(BlueprintType)
struct FAllTransformCapture
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FTransform Position;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FString Name;
};

USTRUCT(BlueprintType)
struct FPipeType
{
	GENERATED_BODY()

public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool IsOpen;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FTransform Transform;
};