void UDemoNetDriver::SpawnDemoRecSpectator( UNetConnection* Connection )
{
check( Connection != NULL );
UClass* C = StaticLoadClass( AActor::StaticClass(), NULL, *DemoSpectatorClass, NULL, LOAD_None, NULL );
if ( C == NULL )
{
UE_LOG( LogDemo, Error, TEXT( "UDemoNetDriver::SpawnDemoRecSpectator: Failed to load demo spectator class." ) );
return;
}
APlayerController* Controller = World->SpawnActor<APlayerController>( C );
if ( Controller == NULL )
{
UE_LOG( LogDemo, Error, TEXT( "UDemoNetDriver::SpawnDemoRecSpectator: Failed to spawn demo spectator." ) );
return;
}
for ( FActorIterator It( World ); It; ++It)
{
if ( It->IsA( APlayerStart::StaticClass() ) )
{
Controller->SetInitialLocationAndRotation( It->GetActorLocation(), It->GetActorRotation() );
break;
}
}
Controller->SetReplicates( true );
Controller->SetAutonomousProxy( true );
Controller->SetPlayer( Connection );
}
void FPlayerMuteList::ServerMutePlayer(APlayerController* OwningPC, const FUniqueNetIdRepl& MuteId)
{
UWorld* World = OwningPC->GetWorld();
const TSharedPtr<const FUniqueNetId>& PlayerIdToMute = MuteId.GetUniqueNetId();
// Don't reprocess if they are already muted
AddIdToMuteList(VoiceMuteList, PlayerIdToMute);
// Add them to the packet filter list if not already on it
AddIdToMuteList(VoicePacketFilter, PlayerIdToMute);
// Replicate mute state to client
OwningPC->ClientMutePlayer(MuteId);
// Find the muted player's player controller so it can be notified
APlayerController* OtherPC = GetPlayerControllerFromNetId(World, *PlayerIdToMute);
if (OtherPC != NULL)
{
// Update their packet filter list too
OtherPC->MuteList.ClientMutePlayer(OtherPC, OwningPC->PlayerState->UniqueId);
// Tell the other PC to mute this one
OtherPC->ClientMutePlayer(OwningPC->PlayerState->UniqueId);
}
}
void APickUpItem::Prox_Implementation(AActor* OtherActor, UPrimitiveComponent* OtherComp, int32
OtherBodyIndex, bool bFromSweep, const FHitResult & SweepResult)
{
// if the overlapped actor is NOT the player,
// you simply should return
if (Cast<AActor>(OtherActor) == nullptr)
{
return;
}
// Get a reference to the player avatar, to give him
// the item
AAvatar *avatar = Cast<AAvatar>(UGameplayStatics::GetPlayerPawn(
GetWorld(), 0));
// Let the player pick up item
// Notice use of keyword this!
// That is how _this_ Pickup can refer to itself.
avatar->Pickup(this);
if (CoinSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, CoinSound, GetActorLocation());
}
// Get a reference to the controller
APlayerController* PController = GetWorld() ->GetFirstPlayerController();
// Get a reference to the HUD from the controller
AMyHUD* hud = Cast<AMyHUD>(PController->GetHUD());
hud->addMessage(Message(Icon, FString("Picked up ") + FString(" ") + Name + FString(" ")+FString::FromInt(Quantity), 2.0f, FColor::Black, FColor::Black));
Destroy();
}
void APawn::PreInitializeComponents()
{
Super::PreInitializeComponents();
if (Instigator == nullptr)
{
Instigator = this;
}
if (AutoPossessPlayer != EAutoReceiveInput::Disabled && GetNetMode() != NM_Client )
{
const int32 PlayerIndex = int32(AutoPossessPlayer.GetValue()) - 1;
APlayerController* PC = UGameplayStatics::GetPlayerController(this, PlayerIndex);
if (PC)
{
PC->Possess(this);
}
else
{
GetWorld()->PersistentLevel->RegisterActorForAutoReceiveInput(this, PlayerIndex);
}
}
UpdateNavigationRelevance();
}
// Called every frame
void ACameraDirector::Tick( float DeltaTime )
{
Super::Tick( DeltaTime );
const float TimeBetweenCameraChanges = 2.0f;
const float SmoothBlendTime = 0.75f;
TimeToNextCameraChange -= DeltaTime;
if (TimeToNextCameraChange <= 0.0f)
{
TimeToNextCameraChange += TimeBetweenCameraChanges;
// Find the actor that handles control for the local player.
APlayerController* OurPlayerController = UGameplayStatics::GetPlayerController(this, 0);
if (OurPlayerController)
{
if ((OurPlayerController->GetViewTarget() != CameraOne) && (CameraOne != nullptr))
{
// Cut instantly to camera one.
OurPlayerController->SetViewTarget(CameraOne);
}
else if ((OurPlayerController->GetViewTarget() != CameraTwo) && (CameraTwo != nullptr))
{
// Blend smoothly to camera two.
OurPlayerController->SetViewTargetWithBlend(CameraTwo, SmoothBlendTime);
}
}
}
}
/**
* Delegate fired when the joining process for an online session has completed
*
* @param SessionName the name of the session this callback is for
* @param bWasSuccessful true if the async action completed without error, false if there was an error
*/
void UOnlineSessionClient::OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type Result)
{
UE_LOG(LogOnline, Verbose, TEXT("OnJoinSessionComplete %s bSuccess: %d"), *SessionName.ToString(), static_cast<int32>(Result));
SessionInt->ClearOnJoinSessionCompleteDelegate(OnJoinSessionCompleteDelegate);
if (Result == EOnJoinSessionCompleteResult::Success)
{
FString URL;
if (SessionInt->GetResolvedConnectString(SessionName, URL))
{
APlayerController* PC = GetPlayerController();
if (PC)
{
if (bIsFromInvite)
{
URL += TEXT("?bIsFromInvite");
bIsFromInvite = false;
}
PC->ClientTravel(URL, TRAVEL_Absolute);
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("Failed to join session %s"), *SessionName.ToString());
}
}
}
void AGameModeBase::PostSeamlessTravel()
{
if (GameSession)
{
GameSession->PostSeamlessTravel();
}
// We have to make a copy of the controller list, since the code after this will destroy
// and create new controllers in the world's list
TArray<TAutoWeakObjectPtr<AController> > OldControllerList;
for (auto It = GetWorld()->GetControllerIterator(); It; ++It)
{
OldControllerList.Add(*It);
}
// Handle players that are already loaded
for (FConstControllerIterator Iterator = OldControllerList.CreateConstIterator(); Iterator; ++Iterator)
{
AController* Controller = *Iterator;
if (Controller->PlayerState)
{
APlayerController* PlayerController = Cast<APlayerController>(Controller);
if (!PlayerController || PlayerController->HasClientLoadedCurrentWorld())
{
// Don't handle if player is still loading world, that gets called in ServerNotifyLoadedWorld
HandleSeamlessTravelPlayer(Controller);
}
}
}
}
void FPlatformerIngameMenu::ReturnToMainMenu()
{
APlatformerPlayerController * PlatformPC = (PCOwner.IsValid())? Cast<APlatformerPlayerController>(PCOwner.Get()) : NULL;
FString RemoteReturnReason = NSLOCTEXT("NetworkErrors", "HostHasLeft", "Host has left the game.").ToString();
FString LocalReturnReason(TEXT(""));
if ( PlatformPC )
{
if (PlatformPC->GetNetMode() < NM_Client)
{
for(auto Iterator = PlatformPC->GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* Controller = *Iterator;
if (Controller && Controller->IsPrimaryPlayer() && Controller != PlatformPC)
{
Controller->ClientReturnToMainMenu(RemoteReturnReason);
}
}
PlatformPC->ClientReturnToMainMenu(LocalReturnReason);
}
else
{
PlatformPC->ClientReturnToMainMenu(LocalReturnReason);
}
}
DestroyRootMenu();
}
void ANetworkController::ReceivedSelectCamera(msgpack_object* Data) {
FString name = Unpack<FString>(Data);
APlayerController* PlayerController = NULL;
for (auto Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator) {
PlayerController = *Iterator;
break;
}
if (!PlayerController) {
return;
}
//PlayerController->PlayerCameraManager->PlayCameraAnim()
for (TActorIterator<ACameraActor> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
ACameraActor* Camera = *ObjIt;
//GEngine->AddOnScreenDebugMessage(-1, 60.f, FColor::Yellow, Camera->GetName());
if (Camera->GetName() == name) {
PlayerController->SetViewTarget(Camera);
AFollowRoadCamera* FollowRoadCamera = Cast<AFollowRoadCamera>(Camera);
if (FollowRoadCamera) {
FollowRoadCamera->Start(false, 0);
}
return;
}
}
}
void UTDCSpectatorPawnMovement::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (!PawnOwner || !UpdatedComponent)
{
return;
}
APlayerController* PlayerController = Cast<APlayerController>(PawnOwner->GetController());
if (PlayerController && PlayerController->IsLocalController())
{
if (!bInitialLocationSet)
{
PawnOwner->SetActorRotation(PlayerController->GetControlRotation());
PawnOwner->SetActorLocation(PlayerController->GetSpawnLocation());
bInitialLocationSet = true;
}
FVector MyLocation = UpdatedComponent->GetComponentLocation();
ATDCSpectatorPawn* SpectatorPawn = Cast<ATDCSpectatorPawn>(PlayerController->GetSpectatorPawn());
if ((SpectatorPawn != NULL) && (SpectatorPawn->GetCameraComponent() != NULL))
{
SpectatorPawn->GetCameraComponent()->ClampCameraLocation(PlayerController, MyLocation);
}
UpdatedComponent->SetWorldLocation(MyLocation, false);
}
}
void UNetGameInstance::OnCompleted(FName SessionName, EOnJoinSessionCompleteResult::Type Result)
{
APlayerController* PC = GetWorld()->GetFirstPlayerController();
FFrame::KismetExecutionMessage(TEXT("Yeeee Join succesful"), ELogVerbosity::Warning);
auto Sessions = Online::GetSessionInterface();
if (Sessions.IsValid())
{
Sessions->ClearOnJoinSessionCompleteDelegate(Delegate);
if (Result == EOnJoinSessionCompleteResult::Success)
{
// Client travel to the server
FString ConnectString;
if (Sessions->GetResolvedConnectString(GameSessionName, ConnectString) && PC->IsValidLowLevel())
{
//UE_LOG(Network, Log, TEXT("Join session: traveling to %s"), *ConnectString);
PC->ClientTravel(ConnectString, TRAVEL_Absolute);
return;
}
}
}
}
PyObject *py_ue_get_player_pawn(ue_PyUObject *self, PyObject * args)
{
ue_py_check(self);
int controller_id = 0;
if (!PyArg_ParseTuple(args, "|i:get_player_pawn", &controller_id))
{
return NULL;
}
UWorld *world = ue_get_uworld(self);
if (!world)
return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");
APlayerController *controller = UGameplayStatics::GetPlayerController(world, controller_id);
if (!controller)
return PyErr_Format(PyExc_Exception, "unable to retrieve controller %d", controller_id);
// the controller could not have a pawn
if (!controller->GetPawn())
Py_RETURN_NONE;
Py_RETURN_UOBJECT(controller->GetPawn());
}
void ACameraDirector::ProcessTransition()
{
APlayerController* PlayerController = UGameplayStatics::GetPlayerController(this, 0);
if (PlayerController)
{
FCameraStruct CameraData = ManagedCameras[CurrentCameraIndex];
AActor* Camera = CameraData.Camera;
float LinearBlend = CameraData.LinearBlend;
if (Camera)
{
if (LinearBlend > 0.f)
{
PlayerController->SetViewTargetWithBlend(Camera, LinearBlend);
}
else
{
PlayerController->SetViewTarget(Camera);
}
}
}
CurrentCameraIndex++;
CurrentCameraIndex = CurrentCameraIndex == ManagedCameras.Num() ? 0 : CurrentCameraIndex;
TimeToNextCameraChange = ManagedCameras[CurrentCameraIndex].TransitionTime;
}
// Called every frame
void ACameraDirector::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
const float TimeBetweenCameraChanges = 60.f;
const float SmoothBlendTime = 59.0f;
TimeToNextCameraChange -= DeltaTime;
if (TimeToNextCameraChange <= 0.0f)
{
TimeToNextCameraChange += TimeBetweenCameraChanges;
//Find actor that handles ctonrtol for local player.
APlayerController* OurPlayerController = UGameplayStatics::GetPlayerController(this, 0);
if (OurPlayerController)
{
if (CameraTwo && (OurPlayerController->GetViewTarget() == CameraOne))
{
//Blend smoothly to camera two.
OurPlayerController->SetViewTargetWithBlend(CameraTwo, SmoothBlendTime);
}
else if (CameraOne)
{
//Cut instantly to camera one.
//OurPlayerController->SetViewTarget(CameraOne);
OurPlayerController->SetViewTargetWithBlend(CameraOne, SmoothBlendTime);
}
}
}
}
void AGameModeBase::InitSeamlessTravelPlayer(AController* NewController)
{
APlayerController* NewPC = Cast<APlayerController>(NewController);
// Find a start spot
AActor* StartSpot = FindPlayerStart(NewController);
if (StartSpot == nullptr)
{
UE_LOG(LogGameMode, Warning, TEXT("Could not find a starting spot"));
}
else
{
FRotator StartRotation(0, StartSpot->GetActorRotation().Yaw, 0);
NewController->SetInitialLocationAndRotation(StartSpot->GetActorLocation(), StartRotation);
}
NewController->StartSpot = StartSpot;
if (NewPC != nullptr)
{
NewPC->PostSeamlessTravel();
if (MustSpectate(NewPC))
{
NewPC->StartSpectatingOnly();
}
else
{
NewPC->bPlayerIsWaiting = true;
NewPC->ChangeState(NAME_Spectating);
NewPC->ClientGotoState(NAME_Spectating);
}
}
}
void AUETutorialGameMode::HandleNewState(EUETutorialGameModeState State)
{
switch (State)
{
case EUETutorialGameModeState::EPlaying:
{
for (ASpawnVolume * Volume : SpawnVolumeActors)
{
Volume->EnableSpawning();
}
break;
}
case EUETutorialGameModeState::EGameOver:
{
for (ASpawnVolume * Volume : SpawnVolumeActors)
{
Volume->DisableSpawning();
}
APlayerController * PlayerController = UGameplayStatics::GetPlayerController(GetWorld(), 0);
PlayerController->SetCinematicMode(true, true, true);
break;
}
case EUETutorialGameModeState::EUnknown:
default:
break;
}
}
void AGameModeBase::GenericPlayerInitialization(AController* C)
{
APlayerController* PC = Cast<APlayerController>(C);
if (PC != nullptr)
{
InitializeHUDForPlayer(PC);
// Notify the game that we can now be muted and mute others
UpdateGameplayMuteList(PC);
// Tell the player to enable voice by default or use the push to talk method
PC->ClientEnableNetworkVoice(!GameSession->RequiresPushToTalk());
ReplicateStreamingStatus(PC);
bool HidePlayer = false, HideHUD = false, DisableMovement = false, DisableTurning = false;
// Check to see if we should start in cinematic mode (matinee movie capture)
if (ShouldStartInCinematicMode(PC, HidePlayer, HideHUD, DisableMovement, DisableTurning))
{
PC->SetCinematicMode(true, HidePlayer, HideHUD, DisableMovement, DisableTurning);
}
// Add the player to any matinees running so that it gets in on any cinematics already running, etc
TArray<AMatineeActor*> AllMatineeActors;
GetWorld()->GetMatineeActors(AllMatineeActors);
for (int32 i = 0; i < AllMatineeActors.Num(); i++)
{
AllMatineeActors[i]->AddPlayerToDirectorTracks(PC);
}
}
}
void ATotemCharacter::CheckShiftKey()
{
//For Sprint, designed only execute on owning client
if (Controller)
{
if (Controller->IsLocalPlayerController())
{
APlayerController* PlayerController = Cast<APlayerController>(Controller);
if (PlayerController)
{
if (PlayerController->IsInputKeyDown(EKeys::LeftShift))
{
// if no move state && on the ground
if (TotemCharacterMoveState == ETotemCharacterMoveState::NoMove && GetCharacterMovement()->IsWalking())
{
SetTotemCharacterMoveState(ETotemCharacterMoveState::Sprint);
}
}
else
{
if (TotemCharacterMoveState == ETotemCharacterMoveState::Sprint)
{
SetTotemCharacterMoveState(ETotemCharacterMoveState::NoMove);
}
}
}
}
}
}
void FBehaviorTreeDebugger::FindLockedDebugActor(UWorld* World)
{
APlayerController* LocalPC = GEngine->GetFirstLocalPlayerController(World);
if (LocalPC && LocalPC->GetHUD() && LocalPC->GetPawnOrSpectator())
{
AGameplayDebuggingReplicator* DebuggingReplicator = NULL;
for (TActorIterator<AGameplayDebuggingReplicator> It(World); It; ++It)
{
AGameplayDebuggingReplicator* A = *It;
if (!A->IsPendingKill())
{
DebuggingReplicator = A;
break;
}
}
const APawn* LockedPawn = DebuggingReplicator != NULL ? Cast<APawn>(DebuggingReplicator->GetSelectedActorToDebug()) : NULL;
UBehaviorTreeComponent* TestInstance = FindInstanceInActor((APawn*)LockedPawn);
if (TestInstance)
{
TreeInstance = TestInstance;
#if USE_BEHAVIORTREE_DEBUGGER
ActiveStepIndex = TestInstance->DebuggerSteps.Num() - 1;
#endif
}
}
}
void AGameSession::HandleMatchHasEnded()
{
if (STATS && !UE_BUILD_SHIPPING)
{
if (FParse::Param(FCommandLine::Get(), TEXT("MatchAutoStatCapture")))
{
UE_LOG(LogGameSession, Log, TEXT("Match has ended - end automatic stat capture"));
GEngine->Exec(GetWorld(), TEXT("stat stopfile"));
}
}
UWorld* World = GetWorld();
if (UOnlineEngineInterface::Get()->DoesSessionExist(World, SessionName))
{
for (FConstPlayerControllerIterator Iterator = World->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
if (!PlayerController->IsLocalController())
{
PlayerController->ClientEndOnlineSession();
}
}
FOnlineSessionStartComplete CompletionDelegate = FOnlineSessionEndComplete::CreateUObject(this, &AGameSession::OnEndSessionComplete);
UOnlineEngineInterface::Get()->EndSession(World, SessionName, CompletionDelegate);
}
}
void APawn::PawnClientRestart()
{
Restart();
APlayerController* PC = Cast<APlayerController>(Controller);
if (PC && PC->IsLocalController())
{
// Handle camera possession
if (PC->bAutoManageActiveCameraTarget)
{
PC->AutoManageActiveCameraTarget(this);
}
// Set up player input component, if there isn't one already.
if (InputComponent == NULL)
{
InputComponent = CreatePlayerInputComponent();
if (InputComponent)
{
SetupPlayerInputComponent(InputComponent);
InputComponent->RegisterComponent();
if (UInputDelegateBinding::SupportsInputDelegate(GetClass()))
{
InputComponent->bBlockInput = bBlockInput;
UInputDelegateBinding::BindInputDelegates(GetClass(), InputComponent);
}
}
}
}
}
void AAvatar::ToggleInventory()
{
APlayerController* PController = GetWorld()->GetFirstPlayerController();
AMyHUD* hud = Cast<AMyHUD>( PController->GetHUD() );
// If inventory is displayed, undisplay it.
if( inventoryShowing )
{
hud->clearWidgets();
inventoryShowing = false;
PController->bShowMouseCursor = false;
return;
}
// Otherwise, display the player's inventory
inventoryShowing = true;
PController->bShowMouseCursor = true;
for( TMap<FString,int>::TIterator it = Backpack.CreateIterator(); it; ++it )
{
// Combine string name of the item, with qty eg Cow x 5
FString fs = it->Key + FString::Printf( TEXT(" x %d"), it->Value );
UTexture2D* tex = NULL;
if( Icons.Find( it->Key ) )
{
tex = Icons[it->Key];
Widget w( Icon( fs, tex ), Classes[it->Key] );
w.bpSpell = Spells[it->Key];
hud->addWidget( w );
}
}
}
void UCheatManager::TestCollisionDistance()
{
APlayerController* PC = GetOuterAPlayerController();
if(PC)
{
// Get view location to act as start point
FVector ViewLoc;
FRotator ViewRot;
PC->GetPlayerViewPoint(ViewLoc, ViewRot);
FlushPersistentDebugLines( GetOuterAPlayerController()->GetWorld() );//change the GetWorld
// calculate from viewloc
for (FObjectIterator Iter(AVolume::StaticClass()); Iter; ++Iter)
{
AVolume * Volume = Cast<AVolume>(*Iter);
if (Volume->GetClass()->GetDefaultObject() != Volume)
{
FVector ClosestPoint(0,0,0);
float Distance = Volume->GetBrushComponent()->GetDistanceToCollision(ViewLoc, ClosestPoint);
float NormalizedDistance = FMath::Clamp<float>(Distance, 0.f, 1000.f)/1000.f;
FColor DrawColor(255*NormalizedDistance, 255*(1-NormalizedDistance), 0);
DrawDebugLine(GetWorld(), ViewLoc, ClosestPoint, DrawColor, true);
UE_LOG(LogCheatManager, Log, TEXT("Distance to (%s) is %0.2f"), *Volume->GetName(), Distance);
}
}
}
}
PyObject *py_ue_is_input_key_down(ue_PyUObject *self, PyObject * args)
{
ue_py_check(self);
char *key;
int controller_id = 0;
if (!PyArg_ParseTuple(args, "s|i:is_input_key_down", &key, &controller_id))
{
return NULL;
}
UWorld *world = ue_get_uworld(self);
if (!world)
return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject");
APlayerController *controller = UGameplayStatics::GetPlayerController(world, controller_id);
if (!controller)
return PyErr_Format(PyExc_Exception, "unable to retrieve controller %d", controller_id);
if (controller->IsInputKeyDown(key))
{
Py_INCREF(Py_True);
return Py_True;
}
Py_INCREF(Py_False);
return Py_False;
}
bool AOpenBarrierConsole::OnInteract()
{
/*When the player interact with the console it activates the camera to enter in puzzle mode*/
UWorld* World = GetWorld();
if (World)
{
APlayerController* PlayerController = World->GetFirstPlayerController();
if (PlayerController)
{
ATGCOPlayerState* PlayerState = Cast<ATGCOPlayerState>(PlayerController->PlayerState);
if (PlayerState)
{
if (PlayerState->eCurrentState == EPlayerStatus::IN_GAME)
{
PlayerState->SwitchGamePuzzle(CameraPuzzle);
}
else
{
if (PlayerState->eCurrentState == EPlayerStatus::IN_PUZZLE_GAME)
{
PlayerState->SwitchGamePuzzle(PlayerController->GetCharacter());
}
}
}
}
}
return true;
}
PyObject *py_ue_input_key(ue_PyUObject * self, PyObject * args)
{
ue_py_check(self);
PyObject *py_fkey;
int event_type;
float amount = 0.0;
PyObject *py_gamepad = nullptr;
int controller_id = 0;
if (!PyArg_ParseTuple(args, "Oi|fO:input_key", &py_fkey, &event_type, &amount, &py_gamepad))
{
return nullptr;;
}
APlayerController *controller = ue_py_check_type<APlayerController>(self);
if (!controller)
return PyErr_Format(PyExc_Exception, "object is not a APlayerController");
FKey *key = ue_py_check_struct<FKey>(py_fkey);
if (!key)
return PyErr_Format(PyExc_Exception, "argument is not a FKey");
if (controller->InputKey(*key, (EInputEvent)event_type, amount, py_gamepad && PyObject_IsTrue(py_gamepad)))
{
Py_RETURN_TRUE;
}
Py_RETURN_FALSE;
}
PyObject *py_ue_input_axis(ue_PyUObject * self, PyObject * args)
{
ue_py_check(self);
PyObject *py_fkey;
float delta;
float delta_time;
int num_samples = 1;
PyObject *py_gamepad = nullptr;
int controller_id = 0;
if (!PyArg_ParseTuple(args, "Off|iO:input_axis", &py_fkey, &delta, &delta_time, &num_samples, &py_gamepad))
{
return nullptr;;
}
APlayerController *controller = ue_py_check_type<APlayerController>(self);
if (!controller)
return PyErr_Format(PyExc_Exception, "object is not a APlayerController");
FKey *key = ue_py_check_struct<FKey>(py_fkey);
if (!key)
return PyErr_Format(PyExc_Exception, "argument is not a FKey");
if (controller->InputAxis(*key, delta, delta_time, num_samples, py_gamepad && PyObject_IsTrue(py_gamepad)))
{
Py_RETURN_TRUE;
}
Py_RETURN_FALSE;
}
void UShowLoginUICallbackProxy::OnShowLoginUICompleted(TSharedPtr<const FUniqueNetId> UniqueId, int LocalPlayerNum)
{
// Update the cached unique ID for the local player and the player state.
APlayerController* PlayerController = PlayerControllerWeakPtr.Get();
if (PlayerController != nullptr)
{
ULocalPlayer* LocalPlayer = PlayerController->GetLocalPlayer();
if (LocalPlayer != nullptr)
{
LocalPlayer->SetCachedUniqueNetId(UniqueId);
}
if (PlayerController->PlayerState != nullptr)
{
PlayerController->PlayerState->SetUniqueId(UniqueId);
}
}
if (UniqueId.IsValid())
{
OnSuccess.Broadcast(PlayerControllerWeakPtr.Get());
}
else
{
OnFailure.Broadcast(PlayerControllerWeakPtr.Get());
}
}
// @TODO: DEPRECATED, remove.
void ADefaultPawn::Turn(float Val)
{
APlayerController* PC = Cast<APlayerController>(GetController());
if (PC)
{
PC->AddYawInput(Val);
}
}
// @TODO: DEPRECATED, remove.
void ADefaultPawn::LookUp(float Val)
{
APlayerController* PC = Cast<APlayerController>(GetController());
if (PC)
{
PC->AddPitchInput(Val);
}
}