APawn::APawn(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
AutoPossessAI = EAutoPossessAI::PlacedInWorld;
if (HasAnyFlags(RF_ClassDefaultObject) && GetClass() == APawn::StaticClass())
{
AIControllerClass = LoadClass<AController>(NULL, *((UEngine*)(UEngine::StaticClass()->GetDefaultObject()))->AIControllerClassName.ToString(), NULL, LOAD_None, NULL);
}
else
{
AIControllerClass = ((APawn*)APawn::StaticClass()->GetDefaultObject())->AIControllerClass;
}
bCanBeDamaged = true;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
NetPriority = 3.0f;
NetUpdateFrequency = 100.f;
bReplicateMovement = true;
BaseEyeHeight = 64.0f;
AllowedYawError = 10.99f;
bCollideWhenPlacing = true;
SpawnCollisionHandlingMethod = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;
bProcessingOutsideWorldBounds = false;
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
bInputEnabled = true;
}
AWeapon::AWeapon(const FObjectInitializer& ObjectInitializer) :Super(ObjectInitializer){
weaponMesh = ObjectInitializer.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("WeaponMesh"));
weaponMesh->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
weaponMesh->bChartDistanceFactor = true;
weaponMesh->bReceivesDecals = false;
weaponMesh->CastShadow = true;
weaponMesh->SetCollisionObjectType(ECC_WorldDynamic);
weaponMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
weaponMesh->SetCollisionResponseToAllChannels(ECR_Ignore);
RootComponent = weaponMesh;
bPlayingAttackAnim = false;
SetEquiped(false);
bWantsToAttack = false;
bPendingEquip = false;
SetCurrentState(EWeaponState::Idle);
LastAttackTime = 0.0f;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
//bReplicateInstigator = true;
bNetUseOwnerRelevancy = true;
}
ASWeapon::ASWeapon(const class FObjectInitializer& PCIP)
: Super(PCIP)
{
Mesh = PCIP.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("WeaponMesh3P"));
Mesh->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
Mesh->bChartDistanceFactor = true;
Mesh->bReceivesDecals = true;
Mesh->CastShadow = true;
Mesh->SetCollisionObjectType(ECC_WorldDynamic);
Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
Mesh->SetCollisionResponseToAllChannels(ECR_Ignore);
Mesh->SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
RootComponent = Mesh;
bIsEquipped = false;
CurrentState = EWeaponState::Idle;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
//bReplicateInstigator = true;
bNetUseOwnerRelevancy = true;
MuzzleAttachPoint = TEXT("MuzzleFlashSocket");
StorageSlot = EInventorySlot::Primary;
}
AShooterProjectile::AShooterProjectile(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
CollisionComp = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(this, TEXT("SphereComp"));
CollisionComp->InitSphereRadius(5.0f);
CollisionComp->AlwaysLoadOnClient = true;
CollisionComp->AlwaysLoadOnServer = true;
CollisionComp->bTraceComplexOnMove = true;
CollisionComp->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
CollisionComp->SetCollisionObjectType(COLLISION_PROJECTILE);
CollisionComp->SetCollisionResponseToAllChannels(ECR_Ignore);
CollisionComp->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);
CollisionComp->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Block);
CollisionComp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Block);
RootComponent = CollisionComp;
ParticleComp = ObjectInitializer.CreateDefaultSubobject<UParticleSystemComponent>(this, TEXT("ParticleComp"));
ParticleComp->bAutoActivate = false;
ParticleComp->bAutoDestroy = false;
ParticleComp->AttachParent = RootComponent;
MovementComp = ObjectInitializer.CreateDefaultSubobject<UProjectileMovementComponent>(this, TEXT("ProjectileComp"));
MovementComp->UpdatedComponent = CollisionComp;
MovementComp->InitialSpeed = 2000.0f;
MovementComp->MaxSpeed = 2000.0f;
MovementComp->bRotationFollowsVelocity = true;
MovementComp->ProjectileGravityScale = 0.f;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bReplicateMovement = true;
}
ASBombActor::ASBombActor(const class FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
FuzePCS = ObjectInitializer.CreateDefaultSubobject<UParticleSystemComponent>(this, TEXT("Fuze"));
FuzePCS->bAutoActivate = false;
FuzePCS->bAutoDestroy = false;
FuzePCS->AttachParent = RootComponent;
ExplosionPCS = ObjectInitializer.CreateDefaultSubobject<UParticleSystemComponent>(this, TEXT("Explosion"));
ExplosionPCS->bAutoActivate = false;
ExplosionPCS->bAutoDestroy = false;
ExplosionPCS->AttachParent = RootComponent;
AudioComp = ObjectInitializer.CreateDefaultSubobject<UAudioComponent>(this, TEXT("AudioComp"));
AudioComp->bAutoActivate = false;
AudioComp->bAutoDestroy = false;
AudioComp->AttachParent = RootComponent;
// Let the bomb be thrown and roll around
MeshComp->SetSimulatePhysics(true);
MaxFuzeTime = 5.0f;
ExplosionDamage = 100;
ExplosionRadius = 512;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bReplicateMovement = true;
}
AShooterProjectile::AShooterProjectile(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetReplicates(true);
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicateMovement = true;
//!< スフィア
SphereComp = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(this, "SphereComp");
if (nullptr != SphereComp)
{
SphereComp->InitSphereRadius(5.0f);
SphereComp->AlwaysLoadOnClient = true;
SphereComp->AlwaysLoadOnServer = true;
SphereComp->bTraceComplexOnMove = true;
//!< コリジョン
SphereComp->SetCollisionObjectType(ECC_GameTraceChannel_WeaponProjectile);
SphereComp->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
SphereComp->SetCollisionResponseToAllChannels(ECR_Ignore);
SphereComp->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Block);
SphereComp->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Block);
SphereComp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Block);
SetRootComponent(SphereComp);
}
//!< メッシュ
StaticMeshComp = ObjectInitializer.CreateDefaultSubobject<UStaticMeshComponent>(this, "StaticMeshComp");
if (nullptr != StaticMeshComp)
{
//!< メッシュ自体のコリジョンは無し
StaticMeshComp->SetCollisionObjectType(ECC_WorldDynamic);
StaticMeshComp->SetCollisionEnabled(ECollisionEnabled::NoCollision);
StaticMeshComp->SetCollisionResponseToAllChannels(ECR_Ignore);
StaticMeshComp->SetupAttachment(SphereComp);
}
//!< プロジェクタイル
ProjectileMovementComp = ObjectInitializer.CreateDefaultSubobject<UProjectileMovementComponent>(this, "ProjectileMovementComp");
if (nullptr != ProjectileMovementComp)
{
ProjectileMovementComp->InitialSpeed = 2000.0f;
ProjectileMovementComp->MaxSpeed = 2000.0f;
ProjectileMovementComp->bRotationFollowsVelocity = true;
ProjectileMovementComp->ProjectileGravityScale = 0.0f;
//!< ホーミング設定
//ProjectileMovementComp->bIsHomingProjectile = true;
//ProjectileMovementComp->HomingAccelerationMagnitude = ;
//ProjectileMovementComp->HomingTargetComponent = nullptr;
ProjectileMovementComp->SetUpdatedComponent(SphereComp);
}
}
void AGameplayDebuggerReplicator::ServerActivateGameplayDebugger_Implementation(bool bActivate)
{
#if ENABLED_GAMEPLAY_DEBUGGER
bReplicates = !bActivate;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
SetReplicates(bActivate);
SetActorTickEnabled(bActivate);
#endif
}
AWorldSettings::AWorldSettings(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP.DoNotCreateDefaultSubobject(TEXT("Sprite")))
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinder<UClass> DmgType_Environmental_Object;
FConstructorStatics()
: DmgType_Environmental_Object(TEXT("/Engine/EngineDamageTypes/DmgTypeBP_Environmental.DmgTypeBP_Environmental_C"))
{
}
};
static FConstructorStatics ConstructorStatics;
bEnableWorldBoundsChecks = true;
bEnableNavigationSystem = true;
bEnableWorldComposition = false;
bEnableWorldOriginRebasing = true;
KillZ = -HALF_WORLD_MAX1;
KillZDamageType = ConstructorStatics.DmgType_Environmental_Object.Object;
WorldToMeters = 100.f;
GameNetworkManagerClass = AGameNetworkManager::StaticClass();
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
TimeDilation = 1.0f;
MatineeTimeDilation = 1.0f;
DemoPlayTimeDilation = 1.0f;
PackedLightAndShadowMapTextureSize = 1024;
#if WITH_EDITORONLY_DATA
bHiddenEd = true;
#endif // WITH_EDITORONLY_DATA
DefaultColorScale = FVector(1.0f, 1.0f, 1.0f);
bPlaceCellsOnlyAlongCameraTracks = false;
VisibilityCellSize = 200;
VisibilityAggressiveness = VIS_LeastAggressive;
LevelLightingQuality = Quality_MAX;
TSubobjectPtr<UStaticMeshComponent> StaticMeshComponent = PCIP.CreateDefaultSubobject<UStaticMeshComponent>(this, TEXT("StaticMeshComponent0"));
StaticMeshComponent->bHiddenInGame = true;
StaticMeshComponent->BodyInstance.bEnableCollision_DEPRECATED = true;
StaticMeshComponent->SetCollisionProfileName(UCollisionProfile::BlockAll_ProfileName);
StaticMeshComponent->PostPhysicsComponentTick.bCanEverTick = false;
StaticMeshComponent->Mobility = EComponentMobility::Static;
RootComponent = StaticMeshComponent;
#if WITH_EDITORONLY_DATA
bActorLabelEditable = false;
#endif // WITH_EDITORONLY_DATA
}
ASPickupActor::ASPickupActor(const class FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
// All objects that can be picked up are simulated and can be thrown around the level
MeshComp->SetSimulatePhysics(true);
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bReplicateMovement = true;
}
AWorldSettings::AWorldSettings(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer.DoNotCreateDefaultSubobject(TEXT("Sprite")))
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinder<UClass> DmgType_Environmental_Object;
FConstructorStatics()
: DmgType_Environmental_Object(TEXT("/Engine/EngineDamageTypes/DmgTypeBP_Environmental.DmgTypeBP_Environmental_C"))
{
}
};
static FConstructorStatics ConstructorStatics;
bEnableWorldBoundsChecks = true;
bEnableNavigationSystem = true;
bEnableAISystem = true;
bEnableWorldComposition = false;
bEnableWorldOriginRebasing = false;
#if WITH_EDITORONLY_DATA
bEnableHierarchicalLODSystem = false;
FHierarchicalSimplification LODBaseSetup;
HierarchicalLODSetup.Add(LODBaseSetup);
NumHLODLevels = HierarchicalLODSetup.Num();
#endif
KillZ = -HALF_WORLD_MAX1;
KillZDamageType = ConstructorStatics.DmgType_Environmental_Object.Object;
WorldToMeters = 100.f;
DefaultPhysicsVolumeClass = ADefaultPhysicsVolume::StaticClass();
GameNetworkManagerClass = AGameNetworkManager::StaticClass();
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
TimeDilation = 1.0f;
MatineeTimeDilation = 1.0f;
DemoPlayTimeDilation = 1.0f;
PackedLightAndShadowMapTextureSize = 1024;
bHidden = false;
DefaultColorScale = FVector(1.0f, 1.0f, 1.0f);
DefaultMaxDistanceFieldOcclusionDistance = 600;
GlobalDistanceFieldViewDistance = 20000;
bPlaceCellsOnlyAlongCameraTracks = false;
VisibilityCellSize = 200;
VisibilityAggressiveness = VIS_LeastAggressive;
LevelLightingQuality = Quality_MAX;
#if WITH_EDITORONLY_DATA
bActorLabelEditable = false;
#endif // WITH_EDITORONLY_DATA
}
ASkill::ASkill(const FObjectInitializer& objectInitializer)
:Super(objectInitializer)
{
skillState = ESkillState::NoOwner;
bAutoPerform = true;
bAutoCooldownOnInterrupt = false;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
}
AGameState::AGameState(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP
.DoNotCreateDefaultSubobject(TEXT("Sprite")) )
{
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
bReplicateMovement = false;
// Note: this is very important to set to false. Though all replication infos are spawned at run time, during seamless travel
// they are held on to and brought over into the new world. In ULevel::InitializeActors, these PlayerStates may be treated as map/startup actors
// and given static NetGUIDs. This also causes their deletions to be recorded and sent to new clients, which if unlucky due to name conflicts,
// may end up deleting the new PlayerStates they had just spaned.
bNetLoadOnClient = false;
}
//////////////////////////////////////////////////////////////////////////
// ARB_RADIALFORCEACTOR
ARadialForceActor::ARadialForceActor(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
ForceComponent = CreateDefaultSubobject<URadialForceComponent>(TEXT("ForceComponent0"));
#if WITH_EDITOR
SpriteComponent = CreateEditorOnlyDefaultSubobject<UBillboardComponent>(TEXT("Sprite"));
if (SpriteComponent)
{
// Structure to hold one-time initialization
if (!IsRunningCommandlet())
{
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinderOptional<UTexture2D> RadialForceTexture;
FName ID_Physics;
FText NAME_Physics;
FConstructorStatics()
: RadialForceTexture(TEXT("/Engine/EditorResources/S_RadForce.S_RadForce"))
, ID_Physics(TEXT("Physics"))
, NAME_Physics(NSLOCTEXT( "SpriteCategory", "Physics", "Physics" ))
{
}
};
static FConstructorStatics ConstructorStatics;
SpriteComponent->Sprite = ConstructorStatics.RadialForceTexture.Get();
#if WITH_EDITORONLY_DATA
SpriteComponent->SpriteInfo.Category = ConstructorStatics.ID_Physics;
SpriteComponent->SpriteInfo.DisplayName = ConstructorStatics.NAME_Physics;
#endif // WITH_EDITORONLY_DATA
}
SpriteComponent->RelativeScale3D.X = 0.5f;
SpriteComponent->RelativeScale3D.Y = 0.5f;
SpriteComponent->RelativeScale3D.Z = 0.5f;
SpriteComponent->SetupAttachment(ForceComponent);
SpriteComponent->bIsScreenSizeScaled = true;
}
#endif
RootComponent = ForceComponent;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
NetUpdateFrequency = 0.1f;
}
ASpectatorPawn::ASpectatorPawn(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP
.SetDefaultSubobjectClass<USpectatorPawnMovement>(Super::MovementComponentName)
.DoNotCreateDefaultSubobject(Super::MeshComponentName)
)
{
bCanBeDamaged = false;
SetRemoteRoleForBackwardsCompat(ROLE_None);
bReplicates = false;
BaseEyeHeight = 0.0f;
bCollideWhenPlacing = false;
static FName CollisionProfileName(TEXT("Spectator"));
CollisionComponent->SetCollisionProfileName(CollisionProfileName);
}
ALevelScriptActor::ALevelScriptActor(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
#if WITH_EDITORONLY_DATA
bActorLabelEditable = false;
bEditable = false;
#endif // WITH_EDITORONLY_DATA
PrimaryActorTick.bCanEverTick = true;
bCanBeDamaged = false;
bInputEnabled = true;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
}
AMagicBattleSoccerWeapon::AMagicBattleSoccerWeapon(const class FObjectInitializer& OI)
: Super(OI)
{
MyPawn = nullptr;
bIsEquipped = false;
bWantsToFire = false;
bRefiring = false;
LocalState = EWeaponState::Idle;
ServerState = EWeaponState::Idle;
LastFireTime = -99999.0f;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bNetUseOwnerRelevancy = true;
}
AShooterWeapon::AShooterWeapon(const class FPostConstructInitializeProperties& PCIP) : Super(PCIP)
{
Mesh1P = PCIP.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("WeaponMesh1P"));
Mesh1P->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
Mesh1P->bChartDistanceFactor = false;
Mesh1P->bReceivesDecals = false;
Mesh1P->CastShadow = false;
Mesh1P->SetCollisionObjectType(ECC_WorldDynamic);
Mesh1P->SetCollisionEnabled(ECollisionEnabled::NoCollision);
Mesh1P->SetCollisionResponseToAllChannels(ECR_Ignore);
RootComponent = Mesh1P;
Mesh3P = PCIP.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("WeaponMesh3P"));
Mesh3P->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
Mesh3P->bChartDistanceFactor = true;
Mesh3P->bReceivesDecals = false;
Mesh3P->CastShadow = true;
Mesh3P->SetCollisionObjectType(ECC_WorldDynamic);
Mesh3P->SetCollisionEnabled(ECollisionEnabled::NoCollision);
Mesh3P->SetCollisionResponseToAllChannels(ECR_Ignore);
Mesh3P->SetCollisionResponseToChannel(COLLISION_WEAPON, ECR_Block);
Mesh3P->SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
Mesh3P->SetCollisionResponseToChannel(COLLISION_PROJECTILE, ECR_Block);
Mesh3P->AttachParent = Mesh1P;
bLoopedMuzzleFX = false;
bLoopedFireAnim = false;
bPlayingFireAnim = false;
bIsEquipped = false;
bWantsToFire = false;
bPendingReload = false;
bPendingEquip = false;
CurrentState = EWeaponState::Idle;
CurrentAmmo = 0;
CurrentAmmoInClip = 0;
BurstCounter = 0;
LastFireTime = 0.0f;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bReplicateInstigator = true;
bNetUseOwnerRelevancy = true;
}
AGameState::AGameState(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer
.DoNotCreateDefaultSubobject(TEXT("Sprite")) )
{
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bAlwaysRelevant = true;
bReplicateMovement = false;
// Note: this is very important to set to false. Though all replication infos are spawned at run time, during seamless travel
// they are held on to and brought over into the new world. In ULevel::InitializeNetworkActors, these PlayerStates may be treated as map/startup actors
// and given static NetGUIDs. This also causes their deletions to be recorded and sent to new clients, which if unlucky due to name conflicts,
// may end up deleting the new PlayerStates they had just spaned.
bNetLoadOnClient = false;
MatchState = MatchState::EnteringMap;
PreviousMatchState = MatchState::EnteringMap;
// Default to every few seconds.
ServerWorldTimeSecondsUpdateFrequency = 5.f;
}
AShooterPickup::AShooterPickup(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
UCapsuleComponent* CollisionComp = ObjectInitializer.CreateDefaultSubobject<UCapsuleComponent>(this, TEXT("CollisionComp"));
CollisionComp->InitCapsuleSize(40.0f, 50.0f);
CollisionComp->SetCollisionObjectType(COLLISION_PICKUP);
CollisionComp->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
CollisionComp->SetCollisionResponseToAllChannels(ECR_Ignore);
CollisionComp->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
RootComponent = CollisionComp;
PickupPSC = ObjectInitializer.CreateDefaultSubobject<UParticleSystemComponent>(this, TEXT("PickupFX"));
PickupPSC->bAutoActivate = false;
PickupPSC->bAutoDestroy = false;
PickupPSC->AttachParent = RootComponent;
RespawnTime = 10.0f;
bIsActive = false;
PickedUpBy = NULL;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
}
// Sets default values
ASWeapon::ASWeapon()
{
Mesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("WeaponMesh3P"));
Mesh->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered;
Mesh->bReceivesDecals = true;
Mesh->CastShadow = true;
Mesh->SetCollisionObjectType(ECC_WorldDynamic);
Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
Mesh->SetCollisionResponseToAllChannels(ECR_Ignore);
Mesh->SetCollisionResponseToChannel(ECC_Visibility, ECR_Block);
RootComponent = Mesh;
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
bNetUseOwnerRelevancy = true;
StorageSlot = EInventorySlot::Primary;
bIsEquipped = false;
CurrentState = EWeaponState::Idle;
MuzzleAttachPoint = TEXT("MuzzleFlashSocket");
}
ADefaultPawn::ADefaultPawn(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
bCanBeDamaged = true;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
bReplicates = true;
NetPriority = 3.0f;
BaseEyeHeight = 0.0f;
bCollideWhenPlacing = false;
SpawnCollisionHandlingMethod = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
CollisionComponent = CreateDefaultSubobject<USphereComponent>(ADefaultPawn::CollisionComponentName);
CollisionComponent->InitSphereRadius(35.0f);
static FName CollisionProfileName(TEXT("Pawn"));
CollisionComponent->SetCollisionProfileName(CollisionProfileName);
CollisionComponent->CanCharacterStepUpOn = ECB_No;
CollisionComponent->bShouldUpdatePhysicsVolume = true;
CollisionComponent->bCanEverAffectNavigation = false;
CollisionComponent->bDynamicObstacle = true;
RootComponent = CollisionComponent;
MovementComponent = CreateDefaultSubobject<UPawnMovementComponent, UFloatingPawnMovement>(ADefaultPawn::MovementComponentName);
MovementComponent->UpdatedComponent = CollisionComponent;
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh;
FConstructorStatics()
: SphereMesh(TEXT("/Engine/EngineMeshes/Sphere")) {}
};
static FConstructorStatics ConstructorStatics;
MeshComponent = CreateOptionalDefaultSubobject<UStaticMeshComponent>(ADefaultPawn::MeshComponentName);
if (MeshComponent)
{
MeshComponent->SetStaticMesh(ConstructorStatics.SphereMesh.Object);
MeshComponent->AlwaysLoadOnClient = true;
MeshComponent->AlwaysLoadOnServer = true;
MeshComponent->bOwnerNoSee = true;
MeshComponent->bCastDynamicShadow = true;
MeshComponent->bAffectDynamicIndirectLighting = false;
MeshComponent->PrimaryComponentTick.TickGroup = TG_PrePhysics;
MeshComponent->AttachParent = RootComponent;
MeshComponent->SetCollisionProfileName(CollisionProfileName);
const float Scale = CollisionComponent->GetUnscaledSphereRadius() / 160.f; // @TODO: hardcoding known size of EngineMeshes.Sphere. Should use a unit sphere instead.
MeshComponent->SetRelativeScale3D(FVector(Scale));
MeshComponent->bGenerateOverlapEvents = false;
MeshComponent->bCanEverAffectNavigation = false;
}
// This is the default pawn class, we want to have it be able to move out of the box.
bAddDefaultMovementBindings = true;
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
}
void AGameplayDebuggingReplicator::BeginPlay()
{
Super::BeginPlay();
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (Role == ROLE_Authority)
{
bReplicates = false;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
SetReplicates(true);
if (!DebugComponentClass.IsValid() && GetWorld() && GetNetMode() < ENetMode::NM_Client)
{
DebugComponentClass = StaticLoadClass(UGameplayDebuggingComponent::StaticClass(), NULL, *DebugComponentClassName, NULL, LOAD_None, NULL);
if (!DebugComponentClass.IsValid())
{
DebugComponentClass = UGameplayDebuggingComponent::StaticClass();
}
}
GetDebugComponent();
}
if (GetWorld() && GetNetMode() != ENetMode::NM_DedicatedServer)
{
if (GIsEditor)
{
UDebugDrawService::Register(TEXT("DebugAI"), FDebugDrawDelegate::CreateUObject(this, &AGameplayDebuggingReplicator::OnDebugAIDelegate));
}
UDebugDrawService::Register(TEXT("Game"), FDebugDrawDelegate::CreateUObject(this, &AGameplayDebuggingReplicator::DrawDebugDataDelegate));
if (!DebugComponentHUDClass.IsValid())
{
DebugComponentHUDClass = StaticLoadClass(AGameplayDebuggingHUDComponent::StaticClass(), NULL, *DebugComponentHUDClassName, NULL, LOAD_None, NULL);
if (!DebugComponentHUDClass.IsValid())
{
DebugComponentHUDClass = AGameplayDebuggingHUDComponent::StaticClass();
}
}
}
#if WITH_EDITOR
const UEditorEngine* EEngine = Cast<UEditorEngine>(GEngine);
if (EEngine && (EEngine->bIsSimulatingInEditor || EEngine->EditorWorld) && GetWorld() != EEngine->EditorWorld && !IsGlobalInWorld() && GCurrentLevelEditingViewportClient && GCurrentLevelEditingViewportClient->EngineShowFlags.DebugAI)
{
SetIsTemporarilyHiddenInEditor(false);
SetActorHiddenInGame(false);
bHiddenEdLevel = false;
bHiddenEdLayer = false;
bHiddenEd = false;
bEditable = true;
if (DebugComponent)
{
DebugComponent->ServerReplicateData(EDebugComponentMessage::ActivateReplication, EAIDebugDrawDataView::Empty);
FGameplayDebuggerSettings Settings = GameplayDebuggerSettings(this);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::OverHead) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::OverHead);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::Basic) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::Basic);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::BehaviorTree) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::BehaviorTree);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::EQS) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::EQS);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::Perception) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::Perception);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::GameView1) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::GameView1);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::GameView2) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::GameView2);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::GameView3) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::GameView3);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::GameView4) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::GameView4);
DebugComponent->ServerReplicateData(Settings.CheckFlag(EAIDebugDrawDataView::GameView5) ? EDebugComponentMessage::ActivateDataView : EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::GameView5);
}
}
else
{
SetTickableWhenPaused(true);
SetIsTemporarilyHiddenInEditor(true);
SetActorHiddenInGame(false);
bHiddenEdLevel = true;
bHiddenEdLayer = true;
bHiddenEd = true;
bEditable = false;
if (DebugComponent)
{
DebugComponent->ServerReplicateData(EDebugComponentMessage::DeactivateDataView, EAIDebugDrawDataView::Empty);
}
}
#endif
if (GetWorld() && GetNetMode() != ENetMode::NM_DedicatedServer)
{
if (GIsEditor)
{
UDebugDrawService::Register(TEXT("DebugAI"), FDebugDrawDelegate::CreateUObject(this, &AGameplayDebuggingReplicator::OnDebugAIDelegate));
}
UDebugDrawService::Register(TEXT("Game"), FDebugDrawDelegate::CreateUObject(this, &AGameplayDebuggingReplicator::DrawDebugDataDelegate));
if (!DebugComponentHUDClass.IsValid())
{
DebugComponentHUDClass = StaticLoadClass(AGameplayDebuggingHUDComponent::StaticClass(), NULL, *DebugComponentHUDClassName, NULL, LOAD_None, NULL);
if (!DebugComponentHUDClass.IsValid())
{
DebugComponentHUDClass = AGameplayDebuggingHUDComponent::StaticClass();
}
}
}
if (bAutoActivate)
{
OnRep_AutoActivate();
}
#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
AGameplayDebuggingReplicator::AGameplayDebuggingReplicator(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
, MaxEQSQueries(5)
, bIsGlobalInWorld(true)
, LastDrawAtFrame(0)
, PlayerControllersUpdateDelay(0)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinderOptional<UTexture2D> RedIcon;
ConstructorHelpers::FObjectFinderOptional<UTexture2D> GreenIcon;
// both icons are needed to debug AI
FConstructorStatics()
: RedIcon(TEXT("/Engine/EngineResources/AICON-Red.AICON-Red"))
, GreenIcon(TEXT("/Engine/EngineResources/AICON-Green.AICON-Green"))
{
}
};
static FConstructorStatics ConstructorStatics;
DefaultTexture_Red = ConstructorStatics.RedIcon.Get();
DefaultTexture_Green = ConstructorStatics.GreenIcon.Get();
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.bStartWithTickEnabled = false;
USceneComponent* SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneComponent"));
RootComponent = SceneComponent;
#if WITH_EDITOR
SetIsTemporarilyHiddenInEditor(true);
#endif
#if WITH_EDITORONLY_DATA
SetTickableWhenPaused(true);
SetActorHiddenInGame(false);
bHiddenEdLevel = true;
bHiddenEdLayer = true;
bHiddenEd = true;
bEditable = false;
#endif
DebuggerShowFlags = GameplayDebuggerSettings().DebuggerShowFlags;
FGameplayDebuggerSettings Settings = GameplayDebuggerSettings(this);
#define UPDATE_VIEW_PROPS(__FlagName__) __FlagName__ = Settings.CheckFlag(EAIDebugDrawDataView::__FlagName__);
UPDATE_VIEW_PROPS(OverHead);
UPDATE_VIEW_PROPS(Basic);
UPDATE_VIEW_PROPS(BehaviorTree);
UPDATE_VIEW_PROPS(EQS);
UPDATE_VIEW_PROPS(Perception);
UPDATE_VIEW_PROPS(GameView1);
UPDATE_VIEW_PROPS(GameView2);
UPDATE_VIEW_PROPS(GameView3);
UPDATE_VIEW_PROPS(GameView4);
UPDATE_VIEW_PROPS(GameView5);
#undef UPDATE_VIEW_PROPS
EnableEQSOnHUD = true;
if (!HasAnyFlags(RF_ClassDefaultObject))
{
SetActorTickEnabled(true);
bReplicates = false;
SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy);
SetReplicates(true);
AGameplayDebuggingReplicator::OnSelectionChangedDelegate.AddUObject(this, &AGameplayDebuggingReplicator::ServerSetActorToDebug);
}
#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
