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_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_AMonsterActor()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage__Script_ArenaShooter();
OuterClass = AMonsterActor::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, AMonsterActor), 0x0040000000000001);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MonsterActor.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MonsterActor.h"));
MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
MetaData->SetValue(NewProp_Health, TEXT("Category"), TEXT("MonsterActor"));
MetaData->SetValue(NewProp_Health, TEXT("ModuleRelativePath"), TEXT("MonsterActor.h"));
#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_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;
}
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;
}
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_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;
}
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;
}
UClass* Z_Construct_UClass_AArenaShooterProjectile()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage__Script_ArenaShooter();
OuterClass = AArenaShooterProjectile::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20800080;
OuterClass->LinkChild(Z_Construct_UFunction_AArenaShooterProjectile_OnHit());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_ProjectileMovement = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProjectileMovement"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(ProjectileMovement, AArenaShooterProjectile), 0x00400000000a001d, Z_Construct_UClass_UProjectileMovementComponent_NoRegister());
UProperty* NewProp_CollisionComp = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CollisionComp"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(CollisionComp, AArenaShooterProjectile), 0x00400000000b0009, Z_Construct_UClass_USphereComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMapWithOverriddenName(Z_Construct_UFunction_AArenaShooterProjectile_OnHit(), "OnHit"); // 141835008
OuterClass->ClassConfigName = FName(TEXT("Game"));
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("ArenaShooterProjectile.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("ArenaShooterProjectile.h"));
MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("Category"), TEXT("Movement"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("ModuleRelativePath"), TEXT("ArenaShooterProjectile.h"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("ToolTip"), TEXT("Projectile movement component"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("Category"), TEXT("Projectile"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("ModuleRelativePath"), TEXT("ArenaShooterProjectile.h"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("ToolTip"), TEXT("Sphere collision component"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UClass* Z_Construct_UClass_AMeleeWeapon()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage_TheBeginning();
OuterClass = AMeleeWeapon::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
OuterClass->LinkChild(Z_Construct_UFunction_AMeleeWeapon_Prox());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_Mesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Mesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Mesh, AMeleeWeapon), 0x00000000000b001d, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
UProperty* NewProp_ProxBox = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProxBox"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ProxBox, AMeleeWeapon), 0x00000000000b001d, Z_Construct_UClass_UBoxComponent_NoRegister());
UProperty* NewProp_AttackDamage = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("AttackDamage"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(AttackDamage, AMeleeWeapon), 0x0000000000000005);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AMeleeWeapon_Prox()); // 1430101950
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MeleeWeapon.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MeleeWeapon.h"));
MetaData->SetValue(NewProp_Mesh, TEXT("Category"), TEXT("MeleeWeapon"));
MetaData->SetValue(NewProp_Mesh, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_Mesh, TEXT("ModuleRelativePath"), TEXT("MeleeWeapon.h"));
MetaData->SetValue(NewProp_ProxBox, TEXT("Category"), TEXT("MeleeWeapon"));
MetaData->SetValue(NewProp_ProxBox, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_ProxBox, TEXT("ModuleRelativePath"), TEXT("MeleeWeapon.h"));
MetaData->SetValue(NewProp_ProxBox, TEXT("ToolTip"), TEXT("bounding box that determines when melee weapon hit"));
MetaData->SetValue(NewProp_AttackDamage, TEXT("Category"), TEXT("MeleeWeapon"));
MetaData->SetValue(NewProp_AttackDamage, TEXT("ModuleRelativePath"), TEXT("MeleeWeapon.h"));
MetaData->SetValue(NewProp_AttackDamage, TEXT("ToolTip"), TEXT("The amount of damage attacks by this weapon do"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UClass* Z_Construct_UClass_AMyProjectile()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage_GAME2013();
OuterClass = AMyProjectile::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, AMyProjectile), 0x00000800000a0009, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
UProperty* NewProp_Collider = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Collider"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(Collider, AMyProjectile), 0x00000800000a0009, Z_Construct_UClass_USphereComponent_NoRegister());
UProperty* NewProp_MovementComponent = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("MovementComponent"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(MovementComponent, AMyProjectile), 0x00000800000a0009, Z_Construct_UClass_UProjectileMovementComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("MyProjectile.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("MyProjectile.h"));
MetaData->SetValue(NewProp_Mesh, TEXT("Category"), TEXT("MyProjectile"));
MetaData->SetValue(NewProp_Mesh, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_Mesh, TEXT("ModuleRelativePath"), TEXT("MyProjectile.h"));
MetaData->SetValue(NewProp_Collider, TEXT("Category"), TEXT("MyProjectile"));
MetaData->SetValue(NewProp_Collider, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_Collider, TEXT("ModuleRelativePath"), TEXT("MyProjectile.h"));
MetaData->SetValue(NewProp_MovementComponent, TEXT("Category"), TEXT("MyProjectile"));
MetaData->SetValue(NewProp_MovementComponent, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_MovementComponent, TEXT("ModuleRelativePath"), TEXT("MyProjectile.h"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UClass* Z_Construct_UClass_APickup()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage_BatteryCollector();
OuterClass = APickup::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
OuterClass->LinkChild(Z_Construct_UFunction_APickup_IsActive());
OuterClass->LinkChild(Z_Construct_UFunction_APickup_SetActive());
OuterClass->LinkChild(Z_Construct_UFunction_APickup_WasCollected());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_PickupMesh = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("PickupMesh"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(PickupMesh, APickup), 0x00000000000a001d, Z_Construct_UClass_UStaticMeshComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APickup_IsActive()); // 2517952078
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APickup_SetActive()); // 4238410895
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_APickup_WasCollected()); // 55041077
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"));
MetaData->SetValue(NewProp_PickupMesh, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_PickupMesh, TEXT("Category"), TEXT("Pickup"));
MetaData->SetValue(NewProp_PickupMesh, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_PickupMesh, TEXT("ModuleRelativePath"), TEXT("Pickup.h"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UClass* Z_Construct_UClass_AFPSProjectile()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_AActor();
Z_Construct_UPackage_FPSProject();
OuterClass = AFPSProjectile::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
OuterClass->LinkChild(Z_Construct_UFunction_AFPSProjectile_OnHit());
UProperty* NewProp_ProjectileMovement = new(OuterClass, TEXT("ProjectileMovement"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ProjectileMovement, AFPSProjectile), 0x00000000000a001d, Z_Construct_UClass_UProjectileMovementComponent_NoRegister());
UProperty* NewProp_CollisionComp = new(OuterClass, TEXT("CollisionComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CollisionComp, AFPSProjectile), 0x00000000000b0009, Z_Construct_UClass_USphereComponent_NoRegister());
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AFPSProjectile_OnHit()); // 1218505340
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("Category"), TEXT("Movement"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_ProjectileMovement, TEXT("ToolTip"), TEXT("Projectile movement component"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("Category"), TEXT("Projectile"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_CollisionComp, TEXT("ToolTip"), TEXT("Sphere collision component"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
