UClass* Z_Construct_UClass_APickUp()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AFRotating_Decoration();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = APickUp::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_APickUp_WasCollected());

				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APickUp_WasCollected()); // 1133678900
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("PickUp.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("PickUp.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #2
0
	UClass* Z_Construct_UClass_AWeaponMeleeBlunt()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AWeaponMelee();
			Z_Construct_UPackage_GAME2013();
			OuterClass = AWeaponMeleeBlunt::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_Mesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Mesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Mesh, AWeaponMeleeBlunt), 0x00000800000a0009, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("WeaponMeleeBlunt.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("WeaponMeleeBlunt.h"));
				MetaData->SetValue(NewProp_Mesh, TEXT("Category"), TEXT("WeaponMeleeBlunt"));
				MetaData->SetValue(NewProp_Mesh, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_Mesh, TEXT("ModuleRelativePath"), TEXT("WeaponMeleeBlunt.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #3
0
	UClass* Z_Construct_UClass_AHammer()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AWeaponMeleeBlunt();
			Z_Construct_UPackage_GAME2013();
			OuterClass = AHammer::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Hammer.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Hammer.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #4
0
	UClass* Z_Construct_UClass_AWeapon()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_GAME2013();
			OuterClass = AWeapon::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900081;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_AttackSpeed = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("AttackSpeed"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(AttackSpeed, AWeapon), 0x0000080000010001);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Weapon.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Weapon.h"));
				MetaData->SetValue(NewProp_AttackSpeed, TEXT("Category"), TEXT("Weapon"));
				MetaData->SetValue(NewProp_AttackSpeed, TEXT("ModuleRelativePath"), TEXT("Weapon.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #5
0
	UClass* Z_Construct_UClass_AMyPlayerState()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_APlayerState();
			Z_Construct_UPackage_GAME2013();
			OuterClass = AMyPlayerState::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900280;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Input Movement Collision Rendering Utilities|Transformation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MyPlayerState.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MyPlayerState.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #6
0
	UClass* Z_Construct_UClass_UMyPlayerHealthWidget()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_UUserWidget();
			Z_Construct_UPackage_GAME2013();
			OuterClass = UMyPlayerHealthWidget::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20901080;

				OuterClass->LinkChild(Z_Construct_UFunction_UMyPlayerHealthWidget_GetPlayerHealth());

				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_UMyPlayerHealthWidget_GetPlayerHealth()); // 1294304962
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MyPlayerHealthWidget.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MyPlayerHealthWidget.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AFirstAidKit()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_APickUp();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = AFirstAidKit::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("FirstAidKit.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("FirstAidKit.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #8
0
	UClass* Z_Construct_UClass_APuzzle2PlayerController()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_APlayerController();
			Z_Construct_UPackage_Puzzle2();
			OuterClass = APuzzle2PlayerController::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20800284;


				OuterClass->ClassConfigName = FName(TEXT("Game"));
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Collision Rendering Utilities|Transformation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Puzzle2PlayerController.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Puzzle2PlayerController.h"));
				MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("PlayerController class used to enable cursor"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AFPSHUD()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AHUD();
			Z_Construct_UPackage_FPSProject();
			OuterClass = AFPSHUD::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x2090028C;


				OuterClass->ClassConfigName = FName(TEXT("Game"));
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Rendering Actor Input Replication"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("FPSHUD.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("FPSHUD.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AHeavy_Object()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = AHeavy_Object::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


				UProperty* NewProp_Plasa3d = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Plasa3d"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Plasa3d, AHeavy_Object), 0x00000000000a001d, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Heavy_Object.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Heavy_Object.h"));
				MetaData->SetValue(NewProp_Plasa3d, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_Plasa3d, TEXT("Category"), TEXT("Interactive"));
				MetaData->SetValue(NewProp_Plasa3d, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_Plasa3d, TEXT("ModuleRelativePath"), TEXT("Heavy_Object.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ACharacterHUD()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AHUD();
			Z_Construct_UPackage_BatteryCollector();
			OuterClass = ACharacterHUD::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x2090028C;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp__HUDFont = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_HUDFont"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(_HUDFont, ACharacterHUD), 0x0000000000000000, Z_Construct_UClass_UFont_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->ClassConfigName = FName(TEXT("Game"));
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Rendering Actor Input Replication"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("CharacterHUD.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("CharacterHUD.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
				MetaData->SetValue(NewProp__HUDFont, TEXT("ModuleRelativePath"), TEXT("CharacterHUD.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #12
0
	UClass* Z_Construct_UClass_UFindEnemyTask()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_UBTTask_BlackboardBase();
			Z_Construct_UPackage_GAME2013();
			OuterClass = UFindEnemyTask::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20100080;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("FindEnemyTask.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("FindEnemyTask.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ASAMChess_test3GameMode()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AGameMode();
			Z_Construct_UPackage_SAMChess_test3();
			OuterClass = ASAMChess_test3GameMode::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x2090028C;


				OuterClass->ClassConfigName = FName(TEXT("Game"));
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Info Rendering MovementReplication Replication Actor Input Movement Collision Rendering Utilities|Transformation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("SAMChess_test3GameMode.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("SAMChess_test3GameMode.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_UTEst()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_UActorComponent();
			Z_Construct_UPackage__Script_ArenaShooter();
			OuterClass = UTEst::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20B00080;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("BlueprintSpawnableComponent"), TEXT(""));
				MetaData->SetValue(OuterClass, TEXT("ClassGroupNames"), TEXT("Custom"));
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("ComponentReplication"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("TEst.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("TEst.h"));
				MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AMonsterPawn()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_APawn();
			Z_Construct_UPackage__Script_ArenaShooter();
			OuterClass = AMonsterPawn::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_Health = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Health"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(Health, AMonsterPawn), 0x0040000000000001);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MonsterPawn.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MonsterPawn.h"));
				MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
				MetaData->SetValue(NewProp_Health, TEXT("Category"), TEXT("MonsterPawn"));
				MetaData->SetValue(NewProp_Health, TEXT("ModuleRelativePath"), TEXT("MonsterPawn.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ASpawnScript()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage__Script_ArenaShooter();
			OuterClass = ASpawnScript::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("SpawnScript.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("SpawnScript.h"));
				MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
				MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("DECLARE_DYNAMIC_MULTICAST_DELEGATE(FSpawnDelegate);"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AGeneric_Projectile()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = AGeneric_Projectile::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


				UProperty* NewProp_ProjectileMovement = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProjectileMovement"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ProjectileMovement, AGeneric_Projectile), 0x00000000000a001d, Z_Construct_UClass_UProjectileMovementComponent_NoRegister());
				UProperty* NewProp_CollisionComp = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CollisionComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CollisionComp, AGeneric_Projectile), 0x00000000000b0009, Z_Construct_UClass_USphereComponent_NoRegister());
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Generic_Projectile.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Generic_Projectile.h"));
				MetaData->SetValue(NewProp_ProjectileMovement, TEXT("Category"), TEXT("Movement"));
				MetaData->SetValue(NewProp_ProjectileMovement, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_ProjectileMovement, TEXT("ModuleRelativePath"), TEXT("Generic_Projectile.h"));
				MetaData->SetValue(NewProp_CollisionComp, TEXT("Category"), TEXT("Projectile"));
				MetaData->SetValue(NewProp_CollisionComp, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_CollisionComp, TEXT("ModuleRelativePath"), TEXT("Generic_Projectile.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_UMonsterComponent()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_UActorComponent();
			Z_Construct_UPackage__Script_ArenaShooter();
			OuterClass = UMonsterComponent::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20B00080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_Health = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Health"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(Health, UMonsterComponent), 0x0010000000000004);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("BlueprintSpawnableComponent"), TEXT(""));
				MetaData->SetValue(OuterClass, TEXT("ClassGroupNames"), TEXT("Custom"));
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("ComponentReplication"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MonsterComponent.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MonsterComponent.h"));
				MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
				MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("DECLARE_DELEGATE(TakeDamage)"));
				MetaData->SetValue(NewProp_Health, TEXT("Category"), TEXT("MonsterComponent"));
				MetaData->SetValue(NewProp_Health, TEXT("ModuleRelativePath"), TEXT("MonsterComponent.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ABatteryPickup()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_APickup();
			Z_Construct_UPackage_BatteryCollector();
			OuterClass = ABatteryPickup::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp__batteryPower = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_batteryPower"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_batteryPower, ABatteryPickup), 0x0000080000000005);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("BatteryPickup.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("BatteryPickup.h"));
				MetaData->SetValue(NewProp__batteryPower, TEXT("BlueprintProtected"), TEXT("true"));
				MetaData->SetValue(NewProp__batteryPower, TEXT("Category"), TEXT("Power"));
				MetaData->SetValue(NewProp__batteryPower, TEXT("ModuleRelativePath"), TEXT("BatteryPickup.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AProject_Escape_roomGameModeBase()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AGameModeBase();
			Z_Construct_UPackage__Script_Project_Escape_room();
			OuterClass = AProject_Escape_roomGameModeBase::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= (EClassFlags)0x20900288u;


				static TCppClassTypeInfo<TCppClassTypeTraits<AProject_Escape_roomGameModeBase> > StaticCppClassTypeInfo;
				OuterClass->SetCppTypeInfo(&StaticCppClassTypeInfo);
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Info Rendering MovementReplication Replication Actor Input Movement Collision Rendering Utilities|Transformation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Project_Escape_roomGameModeBase.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Project_Escape_roomGameModeBase.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ABatteryCollectorGameMode()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AGameMode();
			Z_Construct_UPackage_BatteryCollector();
			OuterClass = ABatteryCollectorGameMode::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x2088028C;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp__decayRate = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_decayRate"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_decayRate, ABatteryCollectorGameMode), 0x0000080000010005);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->ClassConfigName = FName(TEXT("Game"));
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Info Rendering MovementReplication Replication Actor Input Movement Collision Rendering Utilities|Transformation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("BatteryCollectorGameMode.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorGameMode.h"));
				MetaData->SetValue(OuterClass, TEXT("ShowCategories"), TEXT("Input|MouseInput Input|TouchInput"));
				MetaData->SetValue(NewProp__decayRate, TEXT("Category"), TEXT("Power"));
				MetaData->SetValue(NewProp__decayRate, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorGameMode.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #22
0
	UClass* Z_Construct_UClass_AMyAICharacter()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_ACharacter();
			Z_Construct_UPackage_GAME2013();
			OuterClass = AMyAICharacter::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_BehaviorTree = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BehaviorTree"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(BehaviorTree, AMyAICharacter), 0x0000000000010001, Z_Construct_UClass_UBehaviorTree_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MyAICharacter.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MyAICharacter.h"));
				MetaData->SetValue(NewProp_BehaviorTree, TEXT("Category"), TEXT("MyAICharacter"));
				MetaData->SetValue(NewProp_BehaviorTree, TEXT("ModuleRelativePath"), TEXT("MyAICharacter.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AGalaad()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_ACharacter();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = AGalaad::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_CollectPickUp());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_GetUsableInView());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_IsDead());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_MoveForward());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_MoveRight());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_OnStartJump());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_OnStopJump());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_TriggerOff());
				OuterClass->LinkChild(Z_Construct_UFunction_AGalaad_TriggerOn());

				UProperty* NewProp_CollectionSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CollectionSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CollectionSphere, AGalaad), 0x00000000000a001d, Z_Construct_UClass_USphereComponent_NoRegister());
				UProperty* NewProp_FirstPersonMesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FirstPersonMesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FirstPersonMesh, AGalaad), 0x00000000000b0009, Z_Construct_UClass_USkeletalMeshComponent_NoRegister());
				UProperty* NewProp_FPSViewComponent = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FPSViewComponent"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FPSViewComponent, AGalaad), 0x00000000000a001d, Z_Construct_UClass_UCameraComponent_NoRegister());
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_CollectPickUp()); // 3308455293
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_GetUsableInView()); // 888257778
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_IsDead()); // 3554947735
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_MoveForward()); // 3692682722
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_MoveRight()); // 3996670624
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_OnStartJump()); // 3420266313
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_OnStopJump()); // 4124440179
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_TriggerOff()); // 3033751245
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AGalaad_TriggerOn()); // 1449094536
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation Pawn|Character|InternalEvents"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Galaad.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Galaad.h"));
				MetaData->SetValue(NewProp_CollectionSphere, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_CollectionSphere, TEXT("Category"), TEXT("Pick-Up"));
				MetaData->SetValue(NewProp_CollectionSphere, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_CollectionSphere, TEXT("ModuleRelativePath"), TEXT("Galaad.h"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("Category"), TEXT("Mesh"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("ModuleRelativePath"), TEXT("Galaad.h"));
				MetaData->SetValue(NewProp_FPSViewComponent, TEXT("Category"), TEXT("Camera"));
				MetaData->SetValue(NewProp_FPSViewComponent, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_FPSViewComponent, TEXT("ModuleRelativePath"), TEXT("Galaad.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #24
0
	UClass* Z_Construct_UClass_APickUpItem()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_TheBeginning();
			OuterClass = APickUpItem::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_APickUpItem_Prox());

PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_Icon = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Icon"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Icon, APickUpItem), 0x0000000000000005, Z_Construct_UClass_UTexture2D_NoRegister());
				UProperty* NewProp_Mesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Mesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Mesh, APickUpItem), 0x00000000000b001d, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
				UProperty* NewProp_ProxSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProxSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ProxSphere, APickUpItem), 0x00000000000b001d, Z_Construct_UClass_USphereComponent_NoRegister());
				UProperty* NewProp_Quantity = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Quantity"), RF_Public|RF_Transient|RF_Native) UIntProperty(CPP_PROPERTY_BASE(Quantity, APickUpItem), 0x0000000000000005);
				UProperty* NewProp_CoinSound = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CoinSound"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CoinSound, APickUpItem), 0x0000000000000005, Z_Construct_UClass_USoundBase_NoRegister());
				UProperty* NewProp_Name = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Name"), RF_Public|RF_Transient|RF_Native) UStrProperty(CPP_PROPERTY_BASE(Name, APickUpItem), 0x0000000000000005);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APickUpItem_Prox()); // 2550305280
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Icon, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_Icon, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Icon, TEXT("ToolTip"), TEXT("The icon that represents the object in UI/canvas"));
				MetaData->SetValue(NewProp_Mesh, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_Mesh, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_Mesh, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Mesh, TEXT("ToolTip"), TEXT("The mesh of the item"));
				MetaData->SetValue(NewProp_ProxSphere, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_ProxSphere, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_ProxSphere, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_ProxSphere, TEXT("ToolTip"), TEXT("the sphere you collide with to pick item up"));
				MetaData->SetValue(NewProp_Quantity, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_Quantity, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Quantity, TEXT("ToolTip"), TEXT("How much you are getting"));
				MetaData->SetValue(NewProp_CoinSound, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_CoinSound, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Name, TEXT("Category"), TEXT("Item"));
				MetaData->SetValue(NewProp_Name, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
				MetaData->SetValue(NewProp_Name, TEXT("ToolTip"), TEXT("Sets default values for this actor's properties"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #25
0
	UClass* Z_Construct_UClass_APuzzle2BlockGrid()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_Puzzle2();
			OuterClass = APuzzle2BlockGrid::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20880080;


PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_BlockSpacing = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BlockSpacing"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(BlockSpacing, APuzzle2BlockGrid), 0x0000000000000015);
				UProperty* NewProp_Size = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Size"), RF_Public|RF_Transient|RF_Native) UIntProperty(CPP_PROPERTY_BASE(Size, APuzzle2BlockGrid), 0x0000000000000015);
				UProperty* NewProp_TimerText = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("TimerText"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(TimerText, APuzzle2BlockGrid), 0x00000000000b001d, Z_Construct_UClass_UTextRenderComponent_NoRegister());
				UProperty* NewProp_ScoreText = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ScoreText"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ScoreText, APuzzle2BlockGrid), 0x00000000000b001d, Z_Construct_UClass_UTextRenderComponent_NoRegister());
				UProperty* NewProp_DummyRoot = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("DummyRoot"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(DummyRoot, APuzzle2BlockGrid), 0x00000000000b001d, Z_Construct_UClass_USceneComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("Class used to spawn blocks and manage score"));
				MetaData->SetValue(NewProp_BlockSpacing, TEXT("Category"), TEXT("Grid"));
				MetaData->SetValue(NewProp_BlockSpacing, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(NewProp_BlockSpacing, TEXT("ToolTip"), TEXT("Spacing of blocks"));
				MetaData->SetValue(NewProp_Size, TEXT("Category"), TEXT("Grid"));
				MetaData->SetValue(NewProp_Size, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(NewProp_Size, TEXT("ToolTip"), TEXT("Number of blocks along each side of grid"));
				MetaData->SetValue(NewProp_TimerText, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_TimerText, TEXT("Category"), TEXT("Grid"));
				MetaData->SetValue(NewProp_TimerText, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_TimerText, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(NewProp_TimerText, TEXT("ToolTip"), TEXT("Text component for the score"));
				MetaData->SetValue(NewProp_ScoreText, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_ScoreText, TEXT("Category"), TEXT("Grid"));
				MetaData->SetValue(NewProp_ScoreText, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_ScoreText, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(NewProp_ScoreText, TEXT("ToolTip"), TEXT("Text component for the score"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("Category"), TEXT("Grid"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("ModuleRelativePath"), TEXT("Puzzle2BlockGrid.h"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("ToolTip"), TEXT("Dummy root component"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_AFPSCharacter()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_ACharacter();
			Z_Construct_UPackage_FPSProject();
			OuterClass = AFPSCharacter::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_AFPSCharacter_MoveForward());
				OuterClass->LinkChild(Z_Construct_UFunction_AFPSCharacter_MoveRight());
				OuterClass->LinkChild(Z_Construct_UFunction_AFPSCharacter_OnFire());
				OuterClass->LinkChild(Z_Construct_UFunction_AFPSCharacter_OnStartJump());
				OuterClass->LinkChild(Z_Construct_UFunction_AFPSCharacter_OnStopJump());

				UProperty* NewProp_ProjectileClass = new(OuterClass, TEXT("ProjectileClass"), RF_Public|RF_Transient|RF_Native) UClassProperty(CPP_PROPERTY_BASE(ProjectileClass, AFPSCharacter), 0x0000080000010001, Z_Construct_UClass_AFPSProjectile_NoRegister());
				UProperty* NewProp_MuzzleOffset = new(OuterClass, TEXT("MuzzleOffset"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(MuzzleOffset, AFPSCharacter), 0x0000080000000005, Z_Construct_UScriptStruct_UObject_FVector());
				UProperty* NewProp_FirstPersonMesh = new(OuterClass, TEXT("FirstPersonMesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FirstPersonMesh, AFPSCharacter), 0x00000800000b0009, Z_Construct_UClass_USkeletalMeshComponent_NoRegister());
				UProperty* NewProp_FirstPersonCameraComponent = new(OuterClass, TEXT("FirstPersonCameraComponent"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FirstPersonCameraComponent, AFPSCharacter), 0x00000800000a001d, Z_Construct_UClass_UCameraComponent_NoRegister());
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSCharacter_MoveForward()); // 3145596625
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSCharacter_MoveRight()); // 2567381698
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSCharacter_OnFire()); // 79541872
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSCharacter_OnStartJump()); // 2861848762
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSCharacter_OnStopJump()); // 4223339163
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation AI|Navigation Pawn|Character|InternalEvents"));
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(NewProp_ProjectileClass, TEXT("Category"), TEXT("Projectile"));
				MetaData->SetValue(NewProp_ProjectileClass, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(NewProp_ProjectileClass, TEXT("ToolTip"), TEXT("Projectile class to spawn"));
				MetaData->SetValue(NewProp_MuzzleOffset, TEXT("Category"), TEXT("Gameplay"));
				MetaData->SetValue(NewProp_MuzzleOffset, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(NewProp_MuzzleOffset, TEXT("ToolTip"), TEXT("Gun muzzle's offset from the camera location"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("Category"), TEXT("Mesh"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(NewProp_FirstPersonMesh, TEXT("ToolTip"), TEXT("Pawn mesh: 1st person view (arms; seen only by self)"));
				MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("Category"), TEXT("Camera"));
				MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
				MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("ToolTip"), TEXT("First person camera"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #27
0
	UClass* Z_Construct_UClass_APuzzle2Block()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_Puzzle2();
			OuterClass = APuzzle2Block::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20880080;

				OuterClass->LinkChild(Z_Construct_UFunction_APuzzle2Block_BlockClicked());
				OuterClass->LinkChild(Z_Construct_UFunction_APuzzle2Block_OnFingerPressedBlock());

PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_OwningGrid = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("OwningGrid"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OwningGrid, APuzzle2Block), 0x0000000000000000, Z_Construct_UClass_APuzzle2BlockGrid_NoRegister());
				UProperty* NewProp_BlueMaterial = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BlueMaterial"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(BlueMaterial, APuzzle2Block), 0x0000000000000000, Z_Construct_UClass_UMaterialInstance_NoRegister());
				UProperty* NewProp_OrangeMaterial = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("OrangeMaterial"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OrangeMaterial, APuzzle2Block), 0x0000000000000000, Z_Construct_UClass_UMaterialInstance_NoRegister());
				UProperty* NewProp_BlockMesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BlockMesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(BlockMesh, APuzzle2Block), 0x00000000000b001d, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
				UProperty* NewProp_DummyRoot = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("DummyRoot"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(DummyRoot, APuzzle2Block), 0x00000000000b001d, Z_Construct_UClass_USceneComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APuzzle2Block_BlockClicked()); // 3613489292
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APuzzle2Block_OnFingerPressedBlock()); // 85512730
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("A block that can be clicked"));
				MetaData->SetValue(NewProp_OwningGrid, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(NewProp_OwningGrid, TEXT("ToolTip"), TEXT("Grid that owns us"));
				MetaData->SetValue(NewProp_BlueMaterial, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(NewProp_BlueMaterial, TEXT("ToolTip"), TEXT("Pointer to blue material used on active blocks"));
				MetaData->SetValue(NewProp_OrangeMaterial, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(NewProp_OrangeMaterial, TEXT("ToolTip"), TEXT("Pointer to orange material used on active blocks"));
				MetaData->SetValue(NewProp_BlockMesh, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_BlockMesh, TEXT("Category"), TEXT("Block"));
				MetaData->SetValue(NewProp_BlockMesh, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_BlockMesh, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(NewProp_BlockMesh, TEXT("ToolTip"), TEXT("StaticMesh component for the clickable block"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("Category"), TEXT("Block"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
				MetaData->SetValue(NewProp_DummyRoot, TEXT("ToolTip"), TEXT("Dummy root component"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
Пример #28
0
UClass* Z_Construct_UClass_UObject()
{
    static UClass* OuterClass = NULL;
    if (!OuterClass)
    {
        OuterClass = UObject::StaticClass();
        UObjectForceRegistration(OuterClass);
        UObjectBase::EmitBaseReferences(OuterClass);
        OuterClass->StaticLink();
    }
    check(OuterClass->GetClass());
    return OuterClass;
}
	UClass* Z_Construct_UClass_ASpawnVolume()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_BatteryCollector();
			OuterClass = ASpawnVolume::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_ASpawnVolume_GetRandomPointInVolume());

PRAGMA_DISABLE_DEPRECATION_WARNINGS
				UProperty* NewProp_whereToSpawn = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("whereToSpawn"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(whereToSpawn, ASpawnVolume), 0x00000000000a001d, Z_Construct_UClass_UBoxComponent_NoRegister());
				UProperty* NewProp_spawnDelayRangeHigh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("spawnDelayRangeHigh"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(spawnDelayRangeHigh, ASpawnVolume), 0x0000080000000005);
				UProperty* NewProp_spawnDelayRangeLow = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("spawnDelayRangeLow"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(spawnDelayRangeLow, ASpawnVolume), 0x0000080000000005);
				UProperty* NewProp_whatToSpawn = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("whatToSpawn"), RF_Public|RF_Transient|RF_Native) UClassProperty(CPP_PROPERTY_BASE(whatToSpawn, ASpawnVolume), 0x0004080000000001, Z_Construct_UClass_APickup_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ASpawnVolume_GetRandomPointInVolume()); // 1820850609
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_whereToSpawn, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_whereToSpawn, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_whereToSpawn, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_whereToSpawn, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_spawnDelayRangeHigh, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_spawnDelayRangeHigh, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_spawnDelayRangeHigh, TEXT("ToolTip"), TEXT("Minimum spawn delay"));
				MetaData->SetValue(NewProp_spawnDelayRangeLow, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_spawnDelayRangeLow, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_whatToSpawn, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_whatToSpawn, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}
	UClass* Z_Construct_UClass_ASpawnVolume()
	{
		static UClass* OuterClass = NULL;
		if (!OuterClass)
		{
			Z_Construct_UClass_AActor();
			Z_Construct_UPackage_ProjectErwin();
			OuterClass = ASpawnVolume::StaticClass();
			if (!(OuterClass->ClassFlags & CLASS_Constructed))
			{
				UObjectForceRegistration(OuterClass);
				OuterClass->ClassFlags |= 0x20900080;

				OuterClass->LinkChild(Z_Construct_UFunction_ASpawnVolume_GetRandomPointInVolume());

				UProperty* NewProp_SpawnLocation = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("SpawnLocation"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(SpawnLocation, ASpawnVolume), 0x00000000000a001d, Z_Construct_UClass_UBoxComponent_NoRegister());
				UProperty* NewProp_MaxDelay = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("MaxDelay"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(MaxDelay, ASpawnVolume), 0x0000080000000005);
				UProperty* NewProp_MinDelay = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("MinDelay"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(MinDelay, ASpawnVolume), 0x0000080000000005);
				UProperty* NewProp_ObjectToSpawn = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ObjectToSpawn"), RF_Public|RF_Transient|RF_Native) UClassProperty(CPP_PROPERTY_BASE(ObjectToSpawn, ASpawnVolume), 0x0000080000000001, Z_Construct_UClass_APickUp_NoRegister());
				OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ASpawnVolume_GetRandomPointInVolume()); // 3229088347
				OuterClass->StaticLink();
#if WITH_METADATA
				UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
				MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_SpawnLocation, TEXT("AllowPrivateAccess"), TEXT("true"));
				MetaData->SetValue(NewProp_SpawnLocation, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_SpawnLocation, TEXT("EditInline"), TEXT("true"));
				MetaData->SetValue(NewProp_SpawnLocation, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_SpawnLocation, TEXT("ToolTip"), TEXT("box component to show spawning location"));
				MetaData->SetValue(NewProp_MaxDelay, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_MaxDelay, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_MaxDelay, TEXT("ToolTip"), TEXT("max spawn delay"));
				MetaData->SetValue(NewProp_MinDelay, TEXT("Category"), TEXT("Spawning"));
				MetaData->SetValue(NewProp_MinDelay, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
				MetaData->SetValue(NewProp_MinDelay, TEXT("ToolTip"), TEXT("min spawn delay"));
				MetaData->SetValue(NewProp_ObjectToSpawn, TEXT("Category"), TEXT("Spawing"));
				MetaData->SetValue(NewProp_ObjectToSpawn, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
#endif
			}
		}
		check(OuterClass->GetClass());
		return OuterClass;
	}