ASWeapon::ASWeapon(const class FObjectInitializer& PCIP)
: Super(PCIP)
{
Mesh = PCIP.CreateDefaultSubobject<USkeletalMeshComponent>(this, 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;
bIsEquipped = false;
CurrentState = EWeaponState::Idle;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetReplicates(true);
bNetUseOwnerRelevancy = true;
MuzzleAttachPoint = TEXT("MuzzleFlashSocket");
StorageSlot = EInventorySlot::Primary;
ShotsPerMinute = 700;
StartAmmo = 999;
MaxAmmo = 999;
MaxAmmoPerClip = 30;
NoAnimReloadDuration = 1.5f;
NoEquipAnimDuration = 0.5f;
}
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 = 3.0f;
ExplosionDamage = 100;
ExplosionRadius = 1024;
SetReplicates(true);
bReplicateMovement = true;
}
void APawn::PossessedBy(AController* NewController)
{
AController* const OldController = Controller;
Controller = NewController;
ForceNetUpdate();
if (Controller->PlayerState != NULL)
{
PlayerState = Controller->PlayerState;
}
if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
{
if (GetNetMode() != NM_Standalone)
{
SetReplicates(true);
SetAutonomousProxy(true);
}
}
else
{
CopyRemoteRoleFrom(GetDefault<APawn>());
}
// dispatch Blueprint event if necessary
if (OldController != NewController)
{
ReceivePossessed(Controller);
}
}
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
}
void AItemPickup::BeginPlay()
{
Super::BeginPlay();
// printr("Pickup Spawned");
if (Role < ROLE_Authority)
return;
SetReplicateMovement(true);
SetReplicates(true);
FTimerHandle MyHandle;
GetWorldTimerManager().SetTimer(MyHandle, this, &AItemPickup::ActivatePickupOverlap, PickupCollisionDelay, false);
}
void AOnlineBeaconClient::ClientOnConnected_Implementation()
{
SetConnectionState(EBeaconConnectionState::Open);
BeaconConnection->State = USOCK_Open;
Role = ROLE_Authority;
SetReplicates(true);
SetAutonomousProxy(true);
// Fail safe for connection to server but no client connection RPC
GetWorldTimerManager().ClearTimer(TimerHandle_OnFailure);
// Call the overloaded function for this client class
OnConnected();
}
void APawn::TurnOff()
{
if (Role == ROLE_Authority)
{
SetReplicates(true);
}
// do not block anything, just ignore
SetActorEnableCollision(false);
UPawnMovementComponent* MovementComponent = GetMovementComponent();
if (MovementComponent)
{
MovementComponent->StopMovementImmediately();
MovementComponent->SetComponentTickEnabled(false);
}
DisableComponentsSimulatePhysics();
}
void AOnlineBeaconClient::ClientOnConnected_Implementation()
{
Role = ROLE_Authority;
SetReplicates(true);
SetAutonomousProxy(true);
// Fail safe for connection to server but no client connection RPC
GetWorldTimerManager().ClearTimer(TimerHandle_OnFailure);
if (NetDriver)
{
// Increase timeout while we are connected
NetDriver->InitialConnectTimeout = BeaconConnectionTimeout;
NetDriver->ConnectionTimeout = BeaconConnectionTimeout;
}
// Call the overloaded function for this client class
OnConnected();
}
// Sets default values
ABomb::ABomb()
{
// 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;
SphereComp = CreateDefaultSubobject<USphereComponent>(FName("SphereComp"));
SetRootComponent(SphereComp);
SM = CreateDefaultSubobject<UStaticMeshComponent>(FName("SM"));
SM->SetupAttachment(SphereComp);
ProjectileMovementComp = CreateDefaultSubobject<UProjectileMovementComponent>(FName("ProjectileMovementComp"));
ProjectileMovementComp->bShouldBounce = true;
//Since we need to replicate some functionality
//for this actor, we need to mark it as true
SetReplicates(true);
}
// Sets default values
AC_Item::AC_Item(const class FObjectInitializer& PCIP)
: Super(PCIP)
{
Mesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Weapon Mesh 3P"));
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;
PrimaryActorTick.bCanEverTick = true;
PrimaryActorTick.TickGroup = TG_PrePhysics;
SetReplicates(true);
bNetUseOwnerRelevancy = true;
}
AGASEffectField::AGASEffectField(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
bReplicates = true;
SetReplicates(true);
}
void ANUTActor::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
UWorld* CurWorld = GetWorld();
if (CurWorld != NULL)
{
ENetMode CurNetMode = GEngine != NULL ? GEngine->GetNetMode(CurWorld) : NM_Standalone;
bool bClientTimedOut = CurNetMode != NM_Standalone &&
(CurWorld->RealTimeSeconds - LastAliveTime) > (CurNetMode == NM_Client ? 5.0f : 10.0f);
// Have the client tell the server they are still alive
if (CurNetMode == NM_Client && bClientTimedOut)
{
ServerClientStillAlive();
LastAliveTime = CurWorld->RealTimeSeconds;
}
// Have the server set the owner, when appropriate
if ((Cast<APlayerController>(GetOwner()) == NULL || bClientTimedOut) && GEngine != NULL && CurNetMode != NM_Client)
{
AGameState* GameState = CurWorld->GameState;
if (GameState != NULL)
{
// @todo #JohnBReview: You want this to only happen if no remote players are present (perhaps give all players control instead,
// if this becomes a problem - requires setting things up differently though)
if (CurNetMode == NM_ListenServer || CurNetMode == NM_Standalone)
{
for (FLocalPlayerIterator It(GEngine, CurWorld); It; ++It)
{
if (It->PlayerController != NULL)
{
// Reset LastAliveTime, to give client a chance to send initial 'alive' RPC
LastAliveTime = CurWorld->RealTimeSeconds;
SetOwner(It->PlayerController);
break;
}
}
}
for (int i=0; i<GameState->PlayerArray.Num(); i++)
{
APlayerController* PC = Cast<APlayerController>(GameState->PlayerArray[i] != NULL ?
GameState->PlayerArray[i]->GetOwner() : NULL);
if (PC != NULL && PC != GetOwner() && Cast<UNetConnection>(PC->Player) != NULL)
{
UE_LOG(LogUnitTest, Log, TEXT("Setting NUTActor owner to: %s (%s)"), *PC->GetName(),
*GameState->PlayerArray[i]->PlayerName);
// Reset LastAliveTime, to give client a chance to send initial 'alive' RPC
LastAliveTime = CurWorld->RealTimeSeconds;
SetOwner(PC);
break;
}
}
}
}
// Monitor for the beacon net driver, so it can be hooked
if (bMonitorForBeacon)
{
#if TARGET_UE4_CL < CL_BEACONHOST
UNetDriver* BeaconDriver = GEngine->FindNamedNetDriver(CurWorld, NAME_BeaconDriver);
#else
// Somehow, the beacon driver name got messed up in a subsequent checkin, so now has to be found manually
UNetDriver* BeaconDriver = NULL;
FWorldContext* CurContext = GEngine->GetWorldContextFromWorld(CurWorld);
if (CurContext != NULL)
{
for (auto CurDriverRef : CurContext->ActiveNetDrivers)
{
if (CurDriverRef.NetDriverDef->DefName == NAME_BeaconDriver)
{
BeaconDriver = CurDriverRef.NetDriver;
break;
}
}
}
#endif
// Only hook when a client is connected
if (BeaconDriver != NULL && BeaconDriver->ClientConnections.Num() > 0)
{
HookNetDriver(BeaconDriver);
UE_LOG(LogUnitTest, Log, TEXT("Hooked beacon net driver"));
// Also switch over replication to the beacon net driver
Role = ROLE_None;
SetReplicates(false);
BeaconDriverName = BeaconDriver->NetDriverName;
NetDriverName = BeaconDriverName;
Role = ROLE_Authority;
SetReplicates(true);
// Send an RPC, for force actor channel replication
NetMulticastPing();
bMonitorForBeacon = false;
}
}
}
}
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)
}
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)
}
