(Feat) Add Animation Fps Charater
This commit is contained in:
@@ -0,0 +1,628 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
|
||||
|
||||
#include "MainMenuPlayerController.h"
|
||||
|
||||
#include "CharacterAppearanceComponent.h"
|
||||
#include "CharacterCustomizationWidget.h"
|
||||
#include "CharacterPreviewActor.h"
|
||||
#include "ConfirmDialogWidget.h"
|
||||
#include "EngineUtils.h"
|
||||
#include "Kismet/GameplayStatics.h"
|
||||
#include "Kismet/KismetSystemLibrary.h"
|
||||
#include "MainMenuWidget.h"
|
||||
#include "MenuCameraSpot.h"
|
||||
#include "ScreenFadeComponent.h"
|
||||
#include "SessionSubsystem.h"
|
||||
#include "SettingsMenuWidget.h"
|
||||
#include "SurvivalGameInstance.h"
|
||||
#include "SurvivalUserSettings.h"
|
||||
|
||||
#define LOCTEXT_NAMESPACE "MainMenu"
|
||||
|
||||
namespace
|
||||
{
|
||||
// Le menu reste sous le voile de fondu, qui est en 1000.
|
||||
constexpr int32 ZOrderMainMenu = 0;
|
||||
|
||||
// L'ecran de reglages recouvre le menu, la boite de confirmation passe
|
||||
// devant les deux, et le fondu reste au-dessus de tout a 1000.
|
||||
constexpr int32 ZOrderMainMenuSettings = 50;
|
||||
constexpr int32 ZOrderQuitDialog = 100;
|
||||
}
|
||||
|
||||
AMainMenuPlayerController::AMainMenuPlayerController()
|
||||
{
|
||||
// Meme composant que dans le jeu : un seul fondu a maintenir.
|
||||
ScreenFade = CreateDefaultSubobject<UScreenFadeComponent>(TEXT("ScreenFade"));
|
||||
|
||||
bShowMouseCursor = true;
|
||||
|
||||
QuitDialogMessage = LOCTEXT("QuitConfirm", "Quitter le jeu ?");
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::BeginPlay()
|
||||
{
|
||||
Super::BeginPlay();
|
||||
|
||||
// L'ecran part du noir : sans ca on verrait une frame de la map, cadree
|
||||
// n'importe comment, avant que le fondu ne commence.
|
||||
ScreenFade->SnapToBlack();
|
||||
|
||||
if (AMenuCameraSpot* Spot = PickCameraSpot())
|
||||
{
|
||||
// Sans blend : on arrive directement sur l'angle tire au sort.
|
||||
SetViewTarget(Spot);
|
||||
}
|
||||
else
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : aucune AMenuCameraSpot active dans la map, le menu s'affichera sur la vue par defaut."));
|
||||
}
|
||||
|
||||
// APRES SetViewTarget, jamais avant : les images de chauffe doivent etre
|
||||
// rendues depuis l'angle qu'on va reellement montrer, sinon elles raffinent
|
||||
// un decor qu'on ne verra pas. Le voile est deja noir, donc rien ne fuit.
|
||||
USurvivalGameInstance* SurvivalGameInstance = GetGameInstance<USurvivalGameInstance>();
|
||||
if (SurvivalGameInstance)
|
||||
{
|
||||
SurvivalGameInstance->ResumeWorldRendering();
|
||||
}
|
||||
|
||||
if (MainMenuClass)
|
||||
{
|
||||
MainMenu = CreateWidget<UMainMenuWidget>(this, MainMenuClass);
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->AddToViewport(ZOrderMainMenu);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : MainMenuClass n'est pas assignee, aucun menu ne s'affichera."));
|
||||
}
|
||||
|
||||
// GameAndUI et non UIOnly : UIOnly avale aussi la console et les raccourcis
|
||||
// du moteur, ce qui rend le debug penible. Il n'y a de toute facon aucun
|
||||
// input de jeu dans cette map, rien ne peut passer a travers.
|
||||
FInputModeGameAndUI Mode;
|
||||
Mode.SetLockMouseToViewportBehavior(EMouseLockMode::DoNotLock);
|
||||
Mode.SetHideCursorDuringCapture(false);
|
||||
SetInputMode(Mode);
|
||||
SetShowMouseCursor(true);
|
||||
|
||||
ScreenFade->OnFadeFinished.AddDynamic(this, &AMainMenuPlayerController::HandleFadeFinished);
|
||||
|
||||
// Meme raison qu'en jeu : on laisse le decor rendre quelques images derriere
|
||||
// le voile noir avant de l'eclaircir, le temps que Nanite et les textures
|
||||
// virtuelles se raffinent. Sans ca on voit le terrain passer de sa version
|
||||
// grossiere a la vraie, et les modeles apparaitre un a un.
|
||||
if (SurvivalGameInstance)
|
||||
{
|
||||
SurvivalGameInstance->BeginSceneWarmup(
|
||||
FSimpleDelegate::CreateUObject(this, &AMainMenuPlayerController::StartOpeningFade));
|
||||
}
|
||||
else
|
||||
{
|
||||
StartOpeningFade();
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::StartOpeningFade()
|
||||
{
|
||||
ScreenFade->FadeIn(OpeningFadeDuration);
|
||||
|
||||
if (USessionSubsystem* Sessions = GetGameInstance() ? GetGameInstance()->GetSubsystem<USessionSubsystem>() : nullptr)
|
||||
{
|
||||
Sessions->OnHostFailed.AddDynamic(this, &AMainMenuPlayerController::HandleHostFailed);
|
||||
Sessions->OnJoinFailed.AddDynamic(this, &AMainMenuPlayerController::HandleJoinFailed);
|
||||
Sessions->OnTravelPending.AddDynamic(this, &AMainMenuPlayerController::HandleTravelPending);
|
||||
|
||||
// Revenir au menu depuis une partie laisse la session ouverte : elle
|
||||
// resterait annoncee a tes amis alors que plus personne n'est dedans.
|
||||
Sessions->LeaveSession();
|
||||
|
||||
UE_LOG(LogTemp, Log, TEXT("AMainMenuPlayerController : service en ligne [%s]."), *Sessions->GetOnlineServiceName());
|
||||
}
|
||||
|
||||
// On est arrive : le filet de secours reseau redevient actif pour la
|
||||
// prochaine partie. Sans cette remise a zero, un hote qui relance apres
|
||||
// avoir quitte ne serait plus jamais ramene au menu en cas de coupure.
|
||||
if (USurvivalGameInstance* SurvivalGameInstance = GetGameInstance<USurvivalGameInstance>())
|
||||
{
|
||||
SurvivalGameInstance->ClearReturnToMainMenu();
|
||||
}
|
||||
}
|
||||
|
||||
AMenuCameraSpot* AMainMenuPlayerController::PickCameraSpot()
|
||||
{
|
||||
UWorld* World = GetWorld();
|
||||
if (!World)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
USurvivalGameInstance* SurvivalGameInstance = GetGameInstance<USurvivalGameInstance>();
|
||||
const FName LastUsed = SurvivalGameInstance ? SurvivalGameInstance->GetLastMenuCameraName() : NAME_None;
|
||||
|
||||
// TActorIterator plutot que GetAllActorsOfClass : pas de tableau d'AActor*
|
||||
// intermediaire, pas de cast par element.
|
||||
TArray<AMenuCameraSpot*> AllSpots;
|
||||
TArray<AMenuCameraSpot*> Candidates;
|
||||
for (TActorIterator<AMenuCameraSpot> It(World); It; ++It)
|
||||
{
|
||||
AMenuCameraSpot* Spot = *It;
|
||||
if (!Spot->bEnabled)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
AllSpots.Add(Spot);
|
||||
|
||||
// On ecarte l'angle du dernier passage pour ne pas revoir deux fois de
|
||||
// suite le meme decor en revenant au menu.
|
||||
if (Spot->GetFName() != LastUsed)
|
||||
{
|
||||
Candidates.Add(Spot);
|
||||
}
|
||||
}
|
||||
|
||||
// Une seule camera dans la map : on la reprend plutot que de n'afficher
|
||||
// aucune vue.
|
||||
if (Candidates.Num() == 0)
|
||||
{
|
||||
Candidates = MoveTemp(AllSpots);
|
||||
}
|
||||
|
||||
if (Candidates.Num() == 0)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AMenuCameraSpot* Chosen = Candidates[FMath::RandRange(0, Candidates.Num() - 1)];
|
||||
|
||||
if (SurvivalGameInstance)
|
||||
{
|
||||
SurvivalGameInstance->SetLastMenuCameraName(Chosen->GetFName());
|
||||
}
|
||||
|
||||
return Chosen;
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::StartGame()
|
||||
{
|
||||
// Le fondu est deja lance : on ignore le second clic plutot que d'empiler
|
||||
// deux chargements.
|
||||
if (PendingAction != EMenuPendingAction::None)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// L'ecran de customisation s'intercale ICI, entre le clic et le fondu :
|
||||
// c'est le choix fait pour ce projet, on ne lance pas une partie sans etre
|
||||
// passe par son personnage. Sans classe assignee, on retombe sur l'ancien
|
||||
// comportement -- pratique pour tester le reste sans le traverser.
|
||||
if (CustomizationMenuClass && !CustomizationMenu)
|
||||
{
|
||||
PendingAction = EMenuPendingAction::OpenCustomization;
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
|
||||
// On fond au noir AVANT de bouger la camera : le mannequin est ailleurs
|
||||
// dans la meme map, et un travelling jusqu'a lui traverserait le decor.
|
||||
ScreenFade->FadeOut(CustomizationFadeDuration);
|
||||
return;
|
||||
}
|
||||
|
||||
if (GameLevel.IsNull())
|
||||
{
|
||||
UE_LOG(LogTemp, Error, TEXT("AMainMenuPlayerController : GameLevel n'est pas assignee, impossible de lancer la partie."));
|
||||
return;
|
||||
}
|
||||
|
||||
PendingAction = EMenuPendingAction::StartGame;
|
||||
|
||||
// Le menu reste visible pendant le fondu mais cesse de repondre : cliquer
|
||||
// Quitter pendant le fondu vers la partie serait un piege.
|
||||
//
|
||||
// Le test de visibilite est indispensable : quand on arrive ici depuis
|
||||
// l'ecran de customisation, le menu a ete Collapsed a son ouverture, et
|
||||
// HitTestInvisible le RESSUSCITERAIT -- on verrait reapparaitre Jouer,
|
||||
// Reglages et Quitter par-dessus le personnage qu'on vient de valider.
|
||||
// HitTestInvisible rend non cliquable, il ne cache pas.
|
||||
if (MainMenu && MainMenu->GetVisibility() != ESlateVisibility::Collapsed)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
|
||||
ScreenFade->FadeOut(LeaveFadeDuration);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// Ecran de customisation
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
void AMainMenuPlayerController::OpenCustomization()
|
||||
{
|
||||
// Cherche au moment de l'ouverture et pas au BeginPlay : c'est le seul
|
||||
// endroit ou l'on est sur que la map est entierement chargee, et un
|
||||
// mannequin absent doit rester rattrapable.
|
||||
if (!CharacterPreview)
|
||||
{
|
||||
for (TActorIterator<ACharacterPreviewActor> It(GetWorld()); It; ++It)
|
||||
{
|
||||
CharacterPreview = *It;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!CharacterPreview)
|
||||
{
|
||||
UE_LOG(LogTemp, Warning,
|
||||
TEXT("AMainMenuPlayerController : aucun ACharacterPreviewActor dans la map, l'ecran de customisation est saute."));
|
||||
|
||||
// On ne bloque pas le joueur pour un acteur manquant : meme logique
|
||||
// qu'un echec de session, il a clique Jouer, il veut jouer.
|
||||
CustomizationMenuClass = nullptr;
|
||||
StartGame();
|
||||
return;
|
||||
}
|
||||
|
||||
CustomizationMenu = CreateWidget<UCharacterCustomizationWidget>(this, CustomizationMenuClass);
|
||||
if (!CustomizationMenu)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// TOUJOURS l'apparence par defaut, jamais celle persistee : cet ecran est
|
||||
// une etape de CREATION, pas une reprise. Le jour ou un lobby verifiera que
|
||||
// les quatre joueurs ont valide leur personnage, il lui faudra un point de
|
||||
// depart identique pour tout le monde.
|
||||
//
|
||||
// La persistance ne devient pas inutile pour autant : elle sert au respawn,
|
||||
// et surtout a qui arrive par invitation Steam -- celui-la ne passe jamais
|
||||
// par ici et doit bien avoir un visage.
|
||||
//
|
||||
// « Par defaut » veut dire le DefaultAppearance du mannequin, pas les zeros
|
||||
// du C++ : le personnage de depart se regle ainsi dans BP_CharacterPreview,
|
||||
// a l'oeil et sans recompiler. C'est le meme reglage que celui pose au
|
||||
// BeginPlay, donc l'ouverture de l'ecran ne change rien a ce qu'on voyait.
|
||||
const UCharacterAppearanceComponent* PreviewAppearance = CharacterPreview->GetAppearanceComponent();
|
||||
CustomizationMenu->SetupCustomization(
|
||||
CharacterPreview,
|
||||
PreviewAppearance ? PreviewAppearance->DefaultAppearance : FCharacterAppearance());
|
||||
|
||||
CustomizationMenu->OnConfirmed.AddDynamic(this, &AMainMenuPlayerController::HandleCustomizationConfirmed);
|
||||
CustomizationMenu->OnCancelled.AddDynamic(this, &AMainMenuPlayerController::HandleCustomizationCancelled);
|
||||
|
||||
// Sans blend : l'ecran est noir a cet instant, personne ne voit la bascule.
|
||||
// C'est justement ce que le fondu achete -- un travelling depuis l'angle de
|
||||
// menu jusqu'au mannequin traverserait le decor de la map.
|
||||
SetViewTarget(CharacterPreview);
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::Collapsed);
|
||||
}
|
||||
|
||||
CustomizationMenu->AddToViewport();
|
||||
|
||||
// L'ecran a des boutons ET un clic-glisser : il lui faut la souris, et le
|
||||
// mode UI-only l'empeche de tomber dans le jeu.
|
||||
SetInputMode(FInputModeUIOnly().SetWidgetToFocus(CustomizationMenu->TakeWidget()));
|
||||
SetShowMouseCursor(true);
|
||||
|
||||
ScreenFade->FadeIn(CustomizationFadeDuration);
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleCustomizationConfirmed()
|
||||
{
|
||||
// Persiste ET annonce -- mais nous sommes dans le menu, aucun serveur
|
||||
// n'ecoute encore. Seule la persistance compte ici ; l'annonce partira du
|
||||
// AnnounceCharacterAppearance() d'AFpsPlayerController, une fois la partie
|
||||
// chargee et le PlayerState en place.
|
||||
if (USurvivalUserSettings* Settings = USurvivalUserSettings::Get())
|
||||
{
|
||||
Settings->SetCharacterAppearance(CustomizationMenu->GetAppearance());
|
||||
Settings->SaveSettings();
|
||||
}
|
||||
|
||||
CloseCustomization();
|
||||
|
||||
// La classe est mise de cote le temps du lancement : sans ca, StartGame
|
||||
// rouvrirait l'ecran qu'on vient de fermer.
|
||||
CustomizationMenuClass = nullptr;
|
||||
StartGame();
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleCustomizationCancelled()
|
||||
{
|
||||
// Le fondu de retour est deja lance : on ignore la demande plutot que de le
|
||||
// relancer depuis le debut. La garde compte plus depuis qu'Echap declenche
|
||||
// ce chemin -- une touche se repete bien plus facilement qu'un clic.
|
||||
if (PendingAction != EMenuPendingAction::None)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Meme mecanique qu'a l'aller : on fond, PUIS on bascule la vue. Le retour
|
||||
// se termine dans HandleFadeFinished.
|
||||
PendingAction = EMenuPendingAction::CloseCustomization;
|
||||
|
||||
if (CustomizationMenu)
|
||||
{
|
||||
CustomizationMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
|
||||
ScreenFade->FadeOut(CustomizationFadeDuration);
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::CloseCustomization()
|
||||
{
|
||||
if (CustomizationMenu)
|
||||
{
|
||||
CustomizationMenu->RemoveFromParent();
|
||||
CustomizationMenu = nullptr;
|
||||
}
|
||||
|
||||
// Le menu principal reprend la main : son propre mode d'input est pose par
|
||||
// le Blueprint, on remet simplement le curseur dans un etat coherent.
|
||||
SetInputMode(FInputModeUIOnly());
|
||||
SetShowMouseCursor(true);
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleHostFailed(FText Reason)
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : session indisponible (%s), la partie se lance hors ligne."), *Reason.ToString());
|
||||
|
||||
// Sans session on ouvre quand meme en serveur d'ecoute plutot qu'en solo
|
||||
// sec : l'ecart de cout est nul a un joueur, et ca evite d'avoir deux
|
||||
// facons differentes de demarrer une partie a maintenir.
|
||||
UGameplayStatics::OpenLevelBySoftObjectPtr(this, GameLevel, /*bAbsolute=*/true, TEXT("listen"));
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleTravelPending()
|
||||
{
|
||||
USessionSubsystem* Sessions = GetGameInstance() ? GetGameInstance()->GetSubsystem<USessionSubsystem>() : nullptr;
|
||||
if (!Sessions)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Le menu reste lisible pendant le fondu mais cesse de repondre : cliquer
|
||||
// Jouer alors qu'on part deja rejoindre un ami serait un piege.
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
|
||||
// Exactement la duree que le sous-systeme attend : fondre plus lentement
|
||||
// laisserait voyager avant que l'ecran soit noir, plus vite laisserait un
|
||||
// ecran noir immobile.
|
||||
ScreenFade->FadeOut(Sessions->GetTravelFadeDuration());
|
||||
|
||||
// PendingAction reste a None VOLONTAIREMENT : ce n'est pas nous qui
|
||||
// chargerons la map, c'est le sous-systeme. HandleFadeFinished doit donc ne
|
||||
// rien faire quand ce fondu-la se termine.
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleJoinFailed(FText Reason)
|
||||
{
|
||||
UE_LOG(LogTemp, Error, TEXT("AMainMenuPlayerController : connexion impossible -- %s"), *Reason.ToString());
|
||||
|
||||
// Ici pas de repli : le joueur voulait rejoindre un ami precis. On le rend
|
||||
// simplement a son menu, ecran remonte -- sans quoi un echec le laisserait
|
||||
// devant un noir definitif, ce qui se lit comme un plantage.
|
||||
PendingAction = EMenuPendingAction::None;
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::Visible);
|
||||
}
|
||||
|
||||
ScreenFade->FadeIn(LeaveFadeDuration);
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::QuitGame()
|
||||
{
|
||||
// Une partie est deja en cours de chargement : la question n'a plus de sens.
|
||||
if (PendingAction != EMenuPendingAction::None)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Sans boite assignee on ne bloque pas le joueur dans son menu : on ferme.
|
||||
if (!QuitDialogClass)
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : QuitDialogClass n'est pas assignee, fermeture sans confirmation."));
|
||||
CloseGame();
|
||||
return;
|
||||
}
|
||||
|
||||
// Creee au premier clic seulement, puis reutilisee : une boite qu'on ouvre
|
||||
// et ferme plusieurs fois n'a aucune raison d'etre reconstruite.
|
||||
if (!QuitDialog)
|
||||
{
|
||||
QuitDialog = CreateWidget<UConfirmDialogWidget>(this, QuitDialogClass);
|
||||
if (!QuitDialog)
|
||||
{
|
||||
CloseGame();
|
||||
return;
|
||||
}
|
||||
|
||||
QuitDialog->OnConfirmed.AddDynamic(this, &AMainMenuPlayerController::HandleQuitConfirmed);
|
||||
QuitDialog->OnCancelled.AddDynamic(this, &AMainMenuPlayerController::HandleQuitCancelled);
|
||||
QuitDialog->AddToViewport(ZOrderQuitDialog);
|
||||
}
|
||||
|
||||
QuitDialog->Open(QuitDialogMessage);
|
||||
|
||||
// Le menu reste lisible derriere mais cesse de repondre : sans ca, on
|
||||
// pourrait relancer une partie alors que la question est encore posee.
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::OpenSettings()
|
||||
{
|
||||
// Une partie se charge deja : ouvrir un ecran maintenant serait un piege.
|
||||
if (PendingAction != EMenuPendingAction::None)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (!SettingsMenuClass)
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : SettingsMenuClass n'est pas assignee, les reglages ne s'ouvriront pas."));
|
||||
return;
|
||||
}
|
||||
|
||||
// Creee a la premiere ouverture seulement, puis reutilisee.
|
||||
if (!SettingsMenu)
|
||||
{
|
||||
SettingsMenu = CreateWidget<USettingsMenuWidget>(this, SettingsMenuClass);
|
||||
if (!SettingsMenu)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
SettingsMenu->OnCloseRequested.AddDynamic(this, &AMainMenuPlayerController::HandleSettingsCloseRequested);
|
||||
SettingsMenu->AddToViewport(ZOrderMainMenuSettings);
|
||||
|
||||
// Meme ecran qu'en jeu, mais notre pile est plus courte : sa boite se
|
||||
// pose a 60, devant les reglages et derriere celle du bouton Quitter.
|
||||
SettingsMenu->SetDialogZOrder(ZOrderMainMenuSettings + 10);
|
||||
}
|
||||
|
||||
SettingsMenu->Open();
|
||||
|
||||
// Le menu reste lisible derriere mais cesse de repondre : sans ca on
|
||||
// pourrait lancer une partie a travers l'ecran de reglages.
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::HitTestInvisible);
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleSettingsCloseRequested()
|
||||
{
|
||||
if (SettingsMenu)
|
||||
{
|
||||
SettingsMenu->Close();
|
||||
}
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::Visible);
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleQuitConfirmed()
|
||||
{
|
||||
// Pas de fondu : le joueur vient de confirmer, le faire patienter une
|
||||
// seconde de plus ne serait qu'agacant.
|
||||
CloseGame();
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleQuitCancelled()
|
||||
{
|
||||
if (QuitDialog)
|
||||
{
|
||||
QuitDialog->Close();
|
||||
}
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::Visible);
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::CloseGame()
|
||||
{
|
||||
UKismetSystemLibrary::QuitGame(this, this, EQuitPreference::Quit, /*bIgnorePlatformRestrictions=*/false);
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::HandleFadeFinished()
|
||||
{
|
||||
// L'ecran est noir : c'est ICI qu'on bascule la vue sur le mannequin, et
|
||||
// pas au clic. PendingAction est remise a None tout de suite, sinon le
|
||||
// fondu d'eclaircissement qui suit repasserait par la meme branche.
|
||||
if (PendingAction == EMenuPendingAction::OpenCustomization)
|
||||
{
|
||||
PendingAction = EMenuPendingAction::None;
|
||||
OpenCustomization();
|
||||
return;
|
||||
}
|
||||
|
||||
if (PendingAction == EMenuPendingAction::CloseCustomization)
|
||||
{
|
||||
PendingAction = EMenuPendingAction::None;
|
||||
|
||||
CloseCustomization();
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->SetVisibility(ESlateVisibility::Visible);
|
||||
}
|
||||
|
||||
// Un nouvel angle au retour plutot que celui d'avant : PickCameraSpot
|
||||
// evite deja le dernier utilise, donc le menu ne se rouvre jamais sur
|
||||
// exactement la meme image.
|
||||
if (AMenuCameraSpot* Spot = PickCameraSpot())
|
||||
{
|
||||
SetViewTarget(Spot);
|
||||
}
|
||||
|
||||
ScreenFade->FadeIn(CustomizationFadeDuration);
|
||||
return;
|
||||
}
|
||||
|
||||
// Le delegue se declenche aussi a la fin du fondu d'ouverture, ou il n'y a
|
||||
// rien a faire : c'est PendingAction qui distingue les cas.
|
||||
if (PendingAction != EMenuPendingAction::StartGame)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// C'est le sous-systeme qui ouvrira la map, et seulement une fois la session
|
||||
// reellement creee : ouvrir avant donnerait une partie que personne ne peut
|
||||
// rejoindre. Le cas d'echec passe par HandleHostFailed, qui charge quand meme.
|
||||
if (USessionSubsystem* Sessions = GetGameInstance() ? GetGameInstance()->GetSubsystem<USessionSubsystem>() : nullptr)
|
||||
{
|
||||
Sessions->HostSession(GameLevel, USessionSubsystem::DefaultMaxPlayers);
|
||||
}
|
||||
else
|
||||
{
|
||||
UE_LOG(LogTemp, Warning, TEXT("AMainMenuPlayerController : USessionSubsystem introuvable, partie lancee hors ligne."));
|
||||
UGameplayStatics::OpenLevelBySoftObjectPtr(this, GameLevel, /*bAbsolute=*/true, TEXT("listen"));
|
||||
}
|
||||
}
|
||||
|
||||
void AMainMenuPlayerController::EndPlay(const EEndPlayReason::Type EndPlayReason)
|
||||
{
|
||||
if (SettingsMenu)
|
||||
{
|
||||
SettingsMenu->RemoveFromParent();
|
||||
SettingsMenu = nullptr;
|
||||
}
|
||||
|
||||
if (QuitDialog)
|
||||
{
|
||||
QuitDialog->RemoveFromParent();
|
||||
QuitDialog = nullptr;
|
||||
}
|
||||
|
||||
if (MainMenu)
|
||||
{
|
||||
MainMenu->RemoveFromParent();
|
||||
MainMenu = nullptr;
|
||||
}
|
||||
|
||||
Super::EndPlay(EndPlayReason);
|
||||
}
|
||||
|
||||
#undef LOCTEXT_NAMESPACE
|
||||
Reference in New Issue
Block a user