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_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;
}
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;
}
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_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_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_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_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_AMonster()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_ACharacter();
Z_Construct_UPackage_TheBeginning();
OuterClass = AMonster::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_AttackRangeSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("AttackRangeSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(AttackRangeSphere, AMonster), 0x00000000000b001d, Z_Construct_UClass_USphereComponent_NoRegister());
UProperty* NewProp_SightSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("SightSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(SightSphere, AMonster), 0x00000000000b001d, Z_Construct_UClass_USphereComponent_NoRegister());
UProperty* NewProp_TimeSinceLastStrike = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("TimeSinceLastStrike"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(TimeSinceLastStrike, AMonster), 0x0000000000020015);
UProperty* NewProp_AttackTimeout = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("AttackTimeout"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(AttackTimeout, AMonster), 0x0000000000000005);
UProperty* NewProp_BaseAttackDamage = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BaseAttackDamage"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(BaseAttackDamage, AMonster), 0x0000000000000005);
UProperty* NewProp_BPLoot = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BPLoot"), RF_Public|RF_Transient|RF_Native) UClassProperty(CPP_PROPERTY_BASE(BPLoot, AMonster), 0x0000000000000005, Z_Construct_UClass_UObject_NoRegister());
UProperty* NewProp_Experience = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Experience"), RF_Public|RF_Transient|RF_Native) UIntProperty(CPP_PROPERTY_BASE(Experience, AMonster), 0x0000000000000005);
UProperty* NewProp_HitPoints = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("HitPoints"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(HitPoints, AMonster), 0x0000000000000005);
UProperty* NewProp_Speed = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Speed"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(Speed, AMonster), 0x0000000000000005);
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("Monster.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_AttackRangeSphere, TEXT("Category"), TEXT("Collision"));
MetaData->SetValue(NewProp_AttackRangeSphere, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_AttackRangeSphere, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_AttackRangeSphere, TEXT("ToolTip"), TEXT("Range for his attack. Visualizes as a sphere in editor,"));
MetaData->SetValue(NewProp_SightSphere, TEXT("Category"), TEXT("Collision"));
MetaData->SetValue(NewProp_SightSphere, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_SightSphere, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_SightSphere, TEXT("ToolTip"), TEXT("Range for his sight"));
MetaData->SetValue(NewProp_TimeSinceLastStrike, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_TimeSinceLastStrike, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_TimeSinceLastStrike, TEXT("ToolTip"), TEXT("Time since monster's last strike, readable in blueprints"));
MetaData->SetValue(NewProp_AttackTimeout, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_AttackTimeout, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_AttackTimeout, TEXT("ToolTip"), TEXT("Amount of time the monster needs to rest in seconds\nbetween attacking"));
MetaData->SetValue(NewProp_BaseAttackDamage, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_BaseAttackDamage, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_BaseAttackDamage, TEXT("ToolTip"), TEXT("The amount of damage attacks do"));
MetaData->SetValue(NewProp_BPLoot, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_BPLoot, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_BPLoot, TEXT("ToolTip"), TEXT("Blueprint of the type of item dropped by the monster"));
MetaData->SetValue(NewProp_Experience, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_Experience, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_Experience, TEXT("ToolTip"), TEXT("Experience gained for defeating"));
MetaData->SetValue(NewProp_HitPoints, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_HitPoints, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_HitPoints, TEXT("ToolTip"), TEXT("The hitpoints the monster has"));
MetaData->SetValue(NewProp_Speed, TEXT("Category"), TEXT("MonsterProperties"));
MetaData->SetValue(NewProp_Speed, TEXT("ModuleRelativePath"), TEXT("Monster.h"));
MetaData->SetValue(NewProp_Speed, TEXT("ToolTip"), TEXT("How fast he is"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UFunction* Z_Construct_UFunction_APuzzle2Block_OnFingerPressedBlock()
{
struct Puzzle2Block_eventOnFingerPressedBlock_Parms
{
TEnumAsByte<ETouchIndex::Type> FingerIndex;
UPrimitiveComponent* TouchedComponent;
};
UObject* Outer=Z_Construct_UClass_APuzzle2Block();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("OnFingerPressedBlock"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x00020401, 65535, sizeof(Puzzle2Block_eventOnFingerPressedBlock_Parms));
UProperty* NewProp_TouchedComponent = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("TouchedComponent"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(TouchedComponent, Puzzle2Block_eventOnFingerPressedBlock_Parms), 0x0000000000080080, Z_Construct_UClass_UPrimitiveComponent_NoRegister());
UProperty* NewProp_FingerIndex = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("FingerIndex"), RF_Public|RF_Transient|RF_Native) UByteProperty(CPP_PROPERTY_BASE(FingerIndex, Puzzle2Block_eventOnFingerPressedBlock_Parms), 0x0000000000000080, Z_Construct_UEnum_InputCore_ETouchIndex());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("Handle the block being touched"));
MetaData->SetValue(NewProp_TouchedComponent, TEXT("EditInline"), TEXT("true"));
#endif
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_AAvatar()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_ACharacter();
Z_Construct_UPackage_TheBeginning();
OuterClass = AAvatar::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
OuterClass->LinkChild(Z_Construct_UFunction_AAvatar_OnFire());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_FinishGameSound = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FinishGameSound"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FinishGameSound, AAvatar), 0x0000000000000005, Z_Construct_UClass_USoundBase_NoRegister());
UProperty* NewProp_FireSound = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FireSound"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FireSound, AAvatar), 0x0000000000000005, Z_Construct_UClass_USoundBase_NoRegister());
UProperty* NewProp_ProjectileClass = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProjectileClass"), RF_Public|RF_Transient|RF_Native) UClassProperty(CPP_PROPERTY_BASE(ProjectileClass, AAvatar), 0x0004000000010001, Z_Construct_UClass_AFirstPersonProjectile_NoRegister());
UProperty* NewProp_GunOffset = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("GunOffset"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(GunOffset, AAvatar), 0x0000000000000005, Z_Construct_UScriptStruct_FVector());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_AAvatar_OnFire()); // 3370099566
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation"));
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("Avatar.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("Avatar.h"));
MetaData->SetValue(OuterClass, TEXT("ToolTip"), TEXT("forward declare the APickupItem class,\nsince it will be \"mentioned\" in a member function"));
MetaData->SetValue(NewProp_FinishGameSound, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_FinishGameSound, TEXT("ModuleRelativePath"), TEXT("Avatar.h"));
MetaData->SetValue(NewProp_FireSound, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_FireSound, TEXT("ModuleRelativePath"), TEXT("Avatar.h"));
MetaData->SetValue(NewProp_ProjectileClass, TEXT("Category"), TEXT("Projectile"));
MetaData->SetValue(NewProp_ProjectileClass, TEXT("ModuleRelativePath"), TEXT("Avatar.h"));
MetaData->SetValue(NewProp_GunOffset, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_GunOffset, TEXT("ModuleRelativePath"), TEXT("Avatar.h"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UFunction* Z_Construct_UFunction_APuzzle2Block_BlockClicked()
{
struct Puzzle2Block_eventBlockClicked_Parms
{
UPrimitiveComponent* ClickedComp;
};
UObject* Outer=Z_Construct_UClass_APuzzle2Block();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("BlockClicked"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x00020401, 65535, sizeof(Puzzle2Block_eventBlockClicked_Parms));
UProperty* NewProp_ClickedComp = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("ClickedComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ClickedComp, Puzzle2Block_eventBlockClicked_Parms), 0x0000000000080080, Z_Construct_UClass_UPrimitiveComponent_NoRegister());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("Puzzle2Block.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("Handle the block being clicked"));
MetaData->SetValue(NewProp_ClickedComp, TEXT("EditInline"), TEXT("true"));
#endif
}
return ReturnFunction;
}
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_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;
}
UFunction* Z_Construct_UFunction_ANPC_Prox()
{
UObject* Outer=Z_Construct_UClass_ANPC();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("Prox"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x08420C00, 65535, sizeof(NPC_eventProx_Parms));
UProperty* NewProp_SweepResult = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("SweepResult"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(SweepResult, NPC_eventProx_Parms), 0x0000008008000182, Z_Construct_UScriptStruct_FHitResult());
CPP_BOOL_PROPERTY_BITMASK_STRUCT(bFromSweep, NPC_eventProx_Parms, bool);
UProperty* NewProp_bFromSweep = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("bFromSweep"), RF_Public|RF_Transient|RF_Native) UBoolProperty(FObjectInitializer(), EC_CppProperty, CPP_BOOL_PROPERTY_OFFSET(bFromSweep, NPC_eventProx_Parms), 0x0000000000000080, CPP_BOOL_PROPERTY_BITMASK(bFromSweep, NPC_eventProx_Parms), sizeof(bool), true);
UProperty* NewProp_OtherBodyIndex = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherBodyIndex"), RF_Public|RF_Transient|RF_Native) UIntProperty(CPP_PROPERTY_BASE(OtherBodyIndex, NPC_eventProx_Parms), 0x0000000000000080);
UProperty* NewProp_OtherComp = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherComp, NPC_eventProx_Parms), 0x0000000000080080, Z_Construct_UClass_UPrimitiveComponent_NoRegister());
UProperty* NewProp_OtherActor = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherActor"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherActor, NPC_eventProx_Parms), 0x0000000000000080, Z_Construct_UClass_AActor_NoRegister());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("Category"), TEXT("Collision"));
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("NPC.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("The corresponding body of this function is\nANPC::Prox_Implementation, __not__ ANPC::Prox()!\nThis is a bit weird and not what you'd expect,\nbut it happens because this is a BlueprintNativeEvent"));
MetaData->SetValue(NewProp_OtherComp, TEXT("EditInline"), TEXT("true"));
#endif
}
return ReturnFunction;
}
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_ANPC()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_ACharacter();
Z_Construct_UPackage_TheBeginning();
OuterClass = ANPC::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20900080;
OuterClass->LinkChild(Z_Construct_UFunction_ANPC_Prox());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_ProxSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProxSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ProxSphere, ANPC), 0x00000000000a001d, Z_Construct_UClass_USphereComponent_NoRegister());
UProperty* NewProp_ScoreSound = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ScoreSound"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(ScoreSound, ANPC), 0x0000000000000005, Z_Construct_UClass_USoundBase_NoRegister());
UProperty* NewProp_NpcMessage = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("NpcMessage"), RF_Public|RF_Transient|RF_Native) UStrProperty(CPP_PROPERTY_BASE(NpcMessage, ANPC), 0x0000000000000005);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ANPC_Prox()); // 3012133589
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation"));
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("NPC.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("NPC.h"));
MetaData->SetValue(NewProp_ProxSphere, TEXT("Category"), TEXT("Collision"));
MetaData->SetValue(NewProp_ProxSphere, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_ProxSphere, TEXT("ModuleRelativePath"), TEXT("NPC.h"));
MetaData->SetValue(NewProp_ProxSphere, TEXT("ToolTip"), TEXT("Called to bind functionality to input\nvirtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) override;\nThe sphere that the player can collide with to get item"));
MetaData->SetValue(NewProp_ScoreSound, TEXT("Category"), TEXT("Item"));
MetaData->SetValue(NewProp_ScoreSound, TEXT("ModuleRelativePath"), TEXT("NPC.h"));
MetaData->SetValue(NewProp_NpcMessage, TEXT("Category"), TEXT("NPCMessage"));
MetaData->SetValue(NewProp_NpcMessage, TEXT("ModuleRelativePath"), TEXT("NPC.h"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UFunction* Z_Construct_UFunction_ASpawnVolume_GetRandomPointInVolume()
{
struct SpawnVolume_eventGetRandomPointInVolume_Parms
{
FVector ReturnValue;
};
UObject* Outer=Z_Construct_UClass_ASpawnVolume();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("GetRandomPointInVolume"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x14820401, 65535, sizeof(SpawnVolume_eventGetRandomPointInVolume_Parms));
UProperty* NewProp_ReturnValue = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("ReturnValue"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(ReturnValue, SpawnVolume_eventGetRandomPointInVolume_Parms), 0x0000000000000580, Z_Construct_UScriptStruct_FVector());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("Category"), TEXT("Spawning"));
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("SpawnVolume.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("Returns where spawn location is"));
#endif
}
return ReturnFunction;
}
UFunction* Z_Construct_UFunction_APickUpItem_Prox()
{
UObject* Outer=Z_Construct_UClass_APickUpItem();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("Prox"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x08420C00, 65535, sizeof(PickUpItem_eventProx_Parms));
UProperty* NewProp_SweepResult = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("SweepResult"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(SweepResult, PickUpItem_eventProx_Parms), 0x0000008008000182, Z_Construct_UScriptStruct_FHitResult());
CPP_BOOL_PROPERTY_BITMASK_STRUCT(bFromSweep, PickUpItem_eventProx_Parms, bool);
UProperty* NewProp_bFromSweep = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("bFromSweep"), RF_Public|RF_Transient|RF_Native) UBoolProperty(FObjectInitializer(), EC_CppProperty, CPP_BOOL_PROPERTY_OFFSET(bFromSweep, PickUpItem_eventProx_Parms), 0x0000000000000080, CPP_BOOL_PROPERTY_BITMASK(bFromSweep, PickUpItem_eventProx_Parms), sizeof(bool), true);
UProperty* NewProp_OtherBodyIndex = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherBodyIndex"), RF_Public|RF_Transient|RF_Native) UIntProperty(CPP_PROPERTY_BASE(OtherBodyIndex, PickUpItem_eventProx_Parms), 0x0000000000000080);
UProperty* NewProp_OtherComp = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherComp, PickUpItem_eventProx_Parms), 0x0000000000080080, Z_Construct_UClass_UPrimitiveComponent_NoRegister());
UProperty* NewProp_OtherActor = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("OtherActor"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherActor, PickUpItem_eventProx_Parms), 0x0000000000000080, Z_Construct_UClass_AActor_NoRegister());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("Category"), TEXT("Collision"));
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("PickUpItem.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("When something comes inside ProxSphere, this function runs"));
MetaData->SetValue(NewProp_OtherComp, TEXT("EditInline"), TEXT("true"));
#endif
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_AArenaShooterCharacter()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_ACharacter();
Z_Construct_UPackage__Script_ArenaShooter();
OuterClass = AArenaShooterCharacter::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20800080;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_MaxHealth = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("MaxHealth"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(MaxHealth, AArenaShooterCharacter), 0x0020080000000005);
UProperty* NewProp_FireTime = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FireTime"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(FireTime, AArenaShooterCharacter), 0x0020080000000005);
UProperty* NewProp_FireAnimation = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FireAnimation"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(FireAnimation, AArenaShooterCharacter), 0x0010000000000005, Z_Construct_UClass_UAnimMontage_NoRegister());
UProperty* NewProp_FireSound = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FireSound"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(FireSound, AArenaShooterCharacter), 0x0010000000000005, Z_Construct_UClass_USoundBase_NoRegister());
UProperty* NewProp_ProjectileClass = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ProjectileClass"), RF_Public|RF_Transient|RF_MarkAsNative) UClassProperty(CPP_PROPERTY_BASE(ProjectileClass, AArenaShooterCharacter), 0x0014000000010001, Z_Construct_UClass_AArenaShooterProjectile_NoRegister(), UClass::StaticClass());
UProperty* NewProp_GunOffset = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("GunOffset"), RF_Public|RF_Transient|RF_MarkAsNative) UStructProperty(CPP_PROPERTY_BASE(GunOffset, AArenaShooterCharacter), 0x0010000000000005, Z_Construct_UScriptStruct_FVector());
UProperty* NewProp_BaseLookUpRate = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BaseLookUpRate"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(BaseLookUpRate, AArenaShooterCharacter), 0x0010000000020015);
UProperty* NewProp_BaseTurnRate = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BaseTurnRate"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(BaseTurnRate, AArenaShooterCharacter), 0x0010000000020015);
UProperty* NewProp_FirstPersonCameraComponent = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FirstPersonCameraComponent"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(FirstPersonCameraComponent, AArenaShooterCharacter), 0x00400000000a001d, Z_Construct_UClass_UCameraComponent_NoRegister());
UProperty* NewProp_FP_MuzzleLocation = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FP_MuzzleLocation"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(FP_MuzzleLocation, AArenaShooterCharacter), 0x00400000000b0009, Z_Construct_UClass_USceneComponent_NoRegister());
UProperty* NewProp_FP_Gun = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FP_Gun"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(FP_Gun, AArenaShooterCharacter), 0x00400000000b0009, Z_Construct_UClass_USkeletalMeshComponent_NoRegister());
UProperty* NewProp_Mesh1P = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("Mesh1P"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(Mesh1P, AArenaShooterCharacter), 0x00400000000b0009, Z_Construct_UClass_USkeletalMeshComponent_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("Navigation"));
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
MetaData->SetValue(NewProp_MaxHealth, TEXT("Category"), TEXT("ArenaShooterCharacter"));
MetaData->SetValue(NewProp_MaxHealth, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FireTime, TEXT("Category"), TEXT("ArenaShooterCharacter"));
MetaData->SetValue(NewProp_FireTime, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FireAnimation, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_FireAnimation, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FireAnimation, TEXT("ToolTip"), TEXT("AnimMontage to play each time we fire"));
MetaData->SetValue(NewProp_FireSound, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_FireSound, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FireSound, TEXT("ToolTip"), TEXT("Sound to play each time we fire"));
MetaData->SetValue(NewProp_ProjectileClass, TEXT("Category"), TEXT("Projectile"));
MetaData->SetValue(NewProp_ProjectileClass, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_ProjectileClass, TEXT("ToolTip"), TEXT("Projectile class to spawn"));
MetaData->SetValue(NewProp_GunOffset, TEXT("Category"), TEXT("Gameplay"));
MetaData->SetValue(NewProp_GunOffset, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_GunOffset, TEXT("ToolTip"), TEXT("Gun muzzle's offset from the characters location"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("ToolTip"), TEXT("Base look up/down rate, in deg/sec. Other scaling may affect final rate."));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("ToolTip"), TEXT("Base turn rate, in deg/sec. Other scaling may affect final turn rate."));
MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FirstPersonCameraComponent, TEXT("ToolTip"), TEXT("First person camera"));
MetaData->SetValue(NewProp_FP_MuzzleLocation, TEXT("Category"), TEXT("Mesh"));
MetaData->SetValue(NewProp_FP_MuzzleLocation, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_FP_MuzzleLocation, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FP_MuzzleLocation, TEXT("ToolTip"), TEXT("Location on gun mesh where projectiles should spawn."));
MetaData->SetValue(NewProp_FP_Gun, TEXT("Category"), TEXT("Mesh"));
MetaData->SetValue(NewProp_FP_Gun, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_FP_Gun, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_FP_Gun, TEXT("ToolTip"), TEXT("Gun mesh: 1st person view (seen only by self)"));
MetaData->SetValue(NewProp_Mesh1P, TEXT("Category"), TEXT("Mesh"));
MetaData->SetValue(NewProp_Mesh1P, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_Mesh1P, TEXT("ModuleRelativePath"), TEXT("ArenaShooterCharacter.h"));
MetaData->SetValue(NewProp_Mesh1P, TEXT("ToolTip"), TEXT("Pawn mesh: 1st person view (arms; seen only by self)"));
#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_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;
}
UFunction* Z_Construct_UFunction_ABatteryCollectorCharacter_UpdatePower()
{
struct BatteryCollectorCharacter_eventUpdatePower_Parms
{
float _powerChange;
};
UObject* Outer=Z_Construct_UClass_ABatteryCollectorCharacter();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(EC_InternalUseOnlyConstructor, Outer, TEXT("UpdatePower"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x04020401, 65535, sizeof(BatteryCollectorCharacter_eventUpdatePower_Parms));
UProperty* NewProp__powerChange = new(EC_InternalUseOnlyConstructor, ReturnFunction, TEXT("_powerChange"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_powerChange, BatteryCollectorCharacter_eventUpdatePower_Parms), 0x0000000000000080);
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("Category"), TEXT("Power"));
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("Accessor for current power"));
#endif
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_USpawnComponent()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_UActorComponent();
Z_Construct_UPackage__Script_ArenaShooter();
OuterClass = USpawnComponent::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20B00080;
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp_spawn = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("spawn"), RF_Public|RF_Transient|RF_MarkAsNative) UMulticastDelegateProperty(CPP_PROPERTY_BASE(spawn, USpawnComponent), 0x0040000010080000, Z_Construct_UDelegateFunction_ArenaShooter_SpawnDelegate__DelegateSignature());
UProperty* NewProp_SpawnTime = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("SpawnTime"), RF_Public|RF_Transient|RF_MarkAsNative) UFloatProperty(CPP_PROPERTY_BASE(SpawnTime, USpawnComponent), 0x0040000000000001);
UProperty* NewProp_ActorToSpawn = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("ActorToSpawn"), RF_Public|RF_Transient|RF_MarkAsNative) UObjectProperty(CPP_PROPERTY_BASE(ActorToSpawn, USpawnComponent), 0x0040000000000001, Z_Construct_UClass_AActor_NoRegister());
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("SpawnComponent.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("SpawnComponent.h"));
MetaData->SetValue(OuterClass, TEXT("OnlyDefaultConstructorDeclared"), TEXT(""));
MetaData->SetValue(NewProp_spawn, TEXT("ModuleRelativePath"), TEXT("SpawnComponent.h"));
MetaData->SetValue(NewProp_SpawnTime, TEXT("Category"), TEXT("SpawnComponent"));
MetaData->SetValue(NewProp_SpawnTime, TEXT("ModuleRelativePath"), TEXT("SpawnComponent.h"));
MetaData->SetValue(NewProp_ActorToSpawn, TEXT("Category"), TEXT("SpawnComponent"));
MetaData->SetValue(NewProp_ActorToSpawn, TEXT("ModuleRelativePath"), TEXT("SpawnComponent.h"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UClass* Z_Construct_UClass_ABatteryCollectorCharacter()
{
static UClass* OuterClass = NULL;
if (!OuterClass)
{
Z_Construct_UClass_ACharacter();
Z_Construct_UPackage_BatteryCollector();
OuterClass = ABatteryCollectorCharacter::StaticClass();
if (!(OuterClass->ClassFlags & CLASS_Constructed))
{
UObjectForceRegistration(OuterClass);
OuterClass->ClassFlags |= 0x20800080;
OuterClass->LinkChild(Z_Construct_UFunction_ABatteryCollectorCharacter_CollectPickUps());
OuterClass->LinkChild(Z_Construct_UFunction_ABatteryCollectorCharacter_GetCurrentPower());
OuterClass->LinkChild(Z_Construct_UFunction_ABatteryCollectorCharacter_GetInitialPower());
OuterClass->LinkChild(Z_Construct_UFunction_ABatteryCollectorCharacter_PowerChangeEffect());
OuterClass->LinkChild(Z_Construct_UFunction_ABatteryCollectorCharacter_UpdatePower());
PRAGMA_DISABLE_DEPRECATION_WARNINGS
UProperty* NewProp__characterPower = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_characterPower"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_characterPower, ABatteryCollectorCharacter), 0x0000000000020001);
UProperty* NewProp__baseSpeed = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_baseSpeed"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_baseSpeed, ABatteryCollectorCharacter), 0x0000080000000005);
UProperty* NewProp__speedFactor = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_speedFactor"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_speedFactor, ABatteryCollectorCharacter), 0x0000080000000005);
UProperty* NewProp__initialPower = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("_initialPower"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(_initialPower, ABatteryCollectorCharacter), 0x0000080000000005);
UProperty* NewProp_BaseLookUpRate = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BaseLookUpRate"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(BaseLookUpRate, ABatteryCollectorCharacter), 0x0000000000020015);
UProperty* NewProp_BaseTurnRate = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("BaseTurnRate"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(BaseTurnRate, ABatteryCollectorCharacter), 0x0000000000020015);
UProperty* NewProp_CollectionSphere = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CollectionSphere"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CollectionSphere, ABatteryCollectorCharacter), 0x00000000000a001d, Z_Construct_UClass_USphereComponent_NoRegister());
UProperty* NewProp_FollowCamera = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("FollowCamera"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(FollowCamera, ABatteryCollectorCharacter), 0x00000000000a001d, Z_Construct_UClass_UCameraComponent_NoRegister());
UProperty* NewProp_CameraBoom = new(EC_InternalUseOnlyConstructor, OuterClass, TEXT("CameraBoom"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(CameraBoom, ABatteryCollectorCharacter), 0x00000000000a001d, Z_Construct_UClass_USpringArmComponent_NoRegister());
PRAGMA_ENABLE_DEPRECATION_WARNINGS
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ABatteryCollectorCharacter_CollectPickUps()); // 2422444734
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ABatteryCollectorCharacter_GetCurrentPower()); // 1502477587
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ABatteryCollectorCharacter_GetInitialPower()); // 928276474
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ABatteryCollectorCharacter_PowerChangeEffect()); // 2499303425
OuterClass->AddFunctionToFunctionMap(Z_Construct_UFunction_ABatteryCollectorCharacter_UpdatePower()); // 2598552175
OuterClass->ClassConfigName = FName(TEXT("Game"));
OuterClass->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = OuterClass->GetOutermost()->GetMetaData();
MetaData->SetValue(OuterClass, TEXT("HideCategories"), TEXT("Navigation"));
MetaData->SetValue(OuterClass, TEXT("IncludePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(OuterClass, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp__characterPower, TEXT("Category"), TEXT("Power"));
MetaData->SetValue(NewProp__characterPower, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp__baseSpeed, TEXT("BlueprintProtected"), TEXT("true"));
MetaData->SetValue(NewProp__baseSpeed, TEXT("Category"), TEXT("Power"));
MetaData->SetValue(NewProp__baseSpeed, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp__speedFactor, TEXT("BlueprintProtected"), TEXT("true"));
MetaData->SetValue(NewProp__speedFactor, TEXT("Category"), TEXT("Power"));
MetaData->SetValue(NewProp__speedFactor, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp__speedFactor, TEXT("ToolTip"), TEXT("Initial starting power"));
MetaData->SetValue(NewProp__initialPower, TEXT("BlueprintProtected"), TEXT("true"));
MetaData->SetValue(NewProp__initialPower, TEXT("Category"), TEXT("Power"));
MetaData->SetValue(NewProp__initialPower, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp__initialPower, TEXT("ToolTip"), TEXT("Called when we press the E key near a pick up"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp_BaseLookUpRate, TEXT("ToolTip"), TEXT("Base look up/down rate, in deg/sec. Other scaling may affect final rate."));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp_BaseTurnRate, TEXT("ToolTip"), TEXT("Base turn rate, in deg/sec. Other scaling may affect final turn rate."));
MetaData->SetValue(NewProp_CollectionSphere, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_CollectionSphere, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_CollectionSphere, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_CollectionSphere, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp_CollectionSphere, TEXT("ToolTip"), TEXT("Collection Sphere"));
MetaData->SetValue(NewProp_FollowCamera, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_FollowCamera, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_FollowCamera, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_FollowCamera, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp_FollowCamera, TEXT("ToolTip"), TEXT("Follow camera"));
MetaData->SetValue(NewProp_CameraBoom, TEXT("AllowPrivateAccess"), TEXT("true"));
MetaData->SetValue(NewProp_CameraBoom, TEXT("Category"), TEXT("Camera"));
MetaData->SetValue(NewProp_CameraBoom, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_CameraBoom, TEXT("ModuleRelativePath"), TEXT("BatteryCollectorCharacter.h"));
MetaData->SetValue(NewProp_CameraBoom, TEXT("ToolTip"), TEXT("Camera boom positioning the camera behind the character"));
#endif
}
}
check(OuterClass->GetClass());
return OuterClass;
}
UFunction* Z_Construct_UFunction_AFPSProjectile_OnHit()
{
struct FPSProjectile_eventOnHit_Parms
{
class AActor* OtherActor;
class UPrimitiveComponent* OtherComp;
FVector NormalImpulse;
struct FHitResult Hit;
};
UClass* OuterClass=Z_Construct_UClass_AFPSProjectile();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(OuterClass, TEXT("OnHit"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x00C20401, 65535, sizeof(FPSProjectile_eventOnHit_Parms));
UProperty* NewProp_Hit = new(ReturnFunction, TEXT("Hit"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(Hit, FPSProjectile_eventOnHit_Parms), 0x0000000008000182, Z_Construct_UScriptStruct_UEngineTypes_FHitResult());
UProperty* NewProp_NormalImpulse = new(ReturnFunction, TEXT("NormalImpulse"), RF_Public|RF_Transient|RF_Native) UStructProperty(CPP_PROPERTY_BASE(NormalImpulse, FPSProjectile_eventOnHit_Parms), 0x0000000000000080, Z_Construct_UScriptStruct_UObject_FVector());
UProperty* NewProp_OtherComp = new(ReturnFunction, TEXT("OtherComp"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherComp, FPSProjectile_eventOnHit_Parms), 0x0000000000080080, Z_Construct_UClass_UPrimitiveComponent_NoRegister());
UProperty* NewProp_OtherActor = new(ReturnFunction, TEXT("OtherActor"), RF_Public|RF_Transient|RF_Native) UObjectProperty(CPP_PROPERTY_BASE(OtherActor, FPSProjectile_eventOnHit_Parms), 0x0000000000000080, Z_Construct_UClass_AActor_NoRegister());
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("called when projectile hits something"));
MetaData->SetValue(NewProp_Hit, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_NormalImpulse, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_OtherComp, TEXT("EditInline"), TEXT("true"));
MetaData->SetValue(NewProp_OtherComp, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
MetaData->SetValue(NewProp_OtherActor, TEXT("ModuleRelativePath"), TEXT("FPSProjectile.h"));
#endif
}
return ReturnFunction;
}
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;
}
UFunction* Z_Construct_UFunction_AFPSCharacter_MoveRight()
{
struct FPSCharacter_eventMoveRight_Parms
{
float Val;
};
UClass* OuterClass=Z_Construct_UClass_AFPSCharacter();
static UFunction* ReturnFunction = NULL;
if (!ReturnFunction)
{
ReturnFunction = new(OuterClass, TEXT("MoveRight"), RF_Public|RF_Transient|RF_Native) UFunction(FObjectInitializer(), NULL, 0x00080401, 65535, sizeof(FPSCharacter_eventMoveRight_Parms));
UProperty* NewProp_Val = new(ReturnFunction, TEXT("Val"), RF_Public|RF_Transient|RF_Native) UFloatProperty(CPP_PROPERTY_BASE(Val, FPSCharacter_eventMoveRight_Parms), 0x0000000000000080);
ReturnFunction->Bind();
ReturnFunction->StaticLink();
#if WITH_METADATA
UMetaData* MetaData = ReturnFunction->GetOutermost()->GetMetaData();
MetaData->SetValue(ReturnFunction, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
MetaData->SetValue(ReturnFunction, TEXT("ToolTip"), TEXT("handles strafing"));
MetaData->SetValue(NewProp_Val, TEXT("ModuleRelativePath"), TEXT("FPSCharacter.h"));
#endif
}
return ReturnFunction;
}
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;
}
