Configurer les déplacements du personnage

Avant de commencer

Assurez-vous d'avoir terminé et atteint les objectifs suivants dans la section précédente, Créer un personnage joueur avec des actions de commandes :

• Classe de personnage en C++ créée 

• Comprendre le fonctionnement des actions de commandes et des contextes de mappage de commande.

Apprendre à associer une commande et un déplacement

Découvrez un blueprint de personnage d'exemple pour comprendre comment les actions de commandes, les contextes de mappage de commande et le code s'associent pour produire un mouvement. Ensuite, apprenez à reproduire cette fonctionnalité en code.

Visualiser les commandes dans les blueprints

La classe BP_FirstPersonCharacter qui est fournie avec le modèle de première personne est un bon exemple de la façon dont les blueprints et les actions de commandes interagissent.

Dans l'arborescence des ressources du navigateur de contenu, sélectionnez Content > FirstPerson > blueprints. Double-cliquez sur la classe BP_FirstPersonCharacter pour l'ouvrir dans l'Éditeur de blueprint.

Le graphique d'événements du blueprint se trouve au centre de l'Éditeur de blueprint. Le graphique d'événements est un graphique de nœud qui utilise des événements et des appels de fonction pour réaliser une série d'actions ordonnées en réponse au jeu. Dans ce graphique, il y a des groupes de nœuds pour les commandes de caméra, de mouvement et de saut. 

Comprendre la logique de commande de saut

Zoomez sur le groupe Commande de saut. Le nœud EnhancedInputAction IA_Jump représente la ressource d'action de commande IA_Jump que vous avez découverte lors de la dernière étape.

Quand l'action de commande est déclenchée, les événements Started et Triggered sont déclenchés. L'événement Started du nœud mène à un nœud fonctionnel nommé Jump. La classe du personnage parent de ce blueprint dispose d'une fonctionnalité de saut intégrée. Cette fonction est appelée lorsque IA_Jump est déclenché par une pression sur un bouton.

Lorsque le saut s'achève, le nœud déclenche un événement Completed. Cet événement mène à un autre nœud de fonction, Stop Jumping, dont il hérite aussi de la classe de personnage.

Comprendre la logique de commande de déplacement

Intéressons-nous maintenant au groupe Movement Input. Ce groupe commence également avec un nœud correspondant à une action de commande, IA_Move.

Le nœud IA_Move dispose d'un événement Triggered qui se déclenche lorsque l'un des boutons associés à IA_Move est enfoncé.

IA_Move contient également Action Value X et Action Value Y, qui sont les valeurs de mouvement X et Y produites par les commandes du joueur. Les valeurs X et Y étant distinctes, vous devez les appliquer chacune individuellement au personnage.

Le nœud Move est un nœud de fonction personnalisé qui applique le déplacement au personnage. Vous pouvez observer sur le nœud et dans son panneau Détails qu'il nécessite deux entrées nommées Gauche/Droite et Avant/Arrière, et que les valeurs de déplacement X et Y de IA_Move sont transmises à ces entrées. 

Double-cliquez sur le nœud Move ou cliquez sur l'onglet Déplacer au-dessus du graphique pour visualiser la logique à l'intérieur de la fonction.

La fonction commence par un nœud d'entrée de fonction avec ses valeurs d'entrée.    

Le groupe de nœuds Left/Right contient un nœud de fonction Add Movement Input qui ajoute le déplacement au personnage en fonction de deux valeurs : Direction du monde et Valeur d'échelle.

World Direction correspond à la direction dans laquelle le personnage regarde le monde et Scale Value correspond à la quantité de déplacement à appliquer. Étant donné que ce nœud gère le déplacement gauche/droit, il utilise le nœud de fonction Get Actor Right Vector pour obtenir le vecteur droit de la position du personnage dans le monde, puis utilise l'entrée Gauche/Droite (ou la valeur X de l'action d'entrée) comme valeur d'échelle pour appliquer le déplacement le long de ce vecteur.

Si le paramètre Gauche/Droit est défini sur une valeur positive, le personnage se déplace vers le haut sur l'axe des X, ou vers la droite. Si le paramètre Gauche/Droit est défini sur une valeur négative, le personnage se déplace vers le bas de l'axe des X, ou vers la gauche.

Le groupe Avant/Arrière a la même configuration que le groupe Gauche/Droite, mais utilise plutôt l'entrée Avant / Arrière (la valeur Y de l'action d'entrée) pour déterminer la valeur d'échelle le long du vecteur avant de l'acteur.

La réplication de ces nœuds dans le code demande un peu plus d'effort, mais permet un contrôle précis des déplacements de votre personnage.

Assigner les commandes à un joueur avec un ContrôleurDeJoueur

Le contexte de mappage d'entrée mappe l'entrée du joueur sur des actions d'entrée, mais vous devez également connecter ce contexte d'entrée au joueur. Le joueur par défaut utilise la classe ContrôleurDeJoueur et le sous-système de commande.

La ressource ContrôleurDeJoueur fait office de lien entre le joueur humain et les pions qu'il contrôle en jeu. Elle reçoit et traite les entrées du joueur, les traduit en commandes, puis le pion reçoit ces commandes et détermine comment exécuter ce déplacement dans le monde du jeu. Vous pouvez utiliser le même ContrôleurDeJoueur pour contrôler différents pions.

Le ContrôleurDeJoueur peut également :

• Désactiver les commandes durant les scènes cinématiques ou les menus.

• Suivre les scores ou autres données du joueur.

• Faire apparaître ou masquer des éléments de l'interface.

La distinction entre le ContrôleurDeJoueur et le personnage permet d'assurer la flexibilité et la persistance des données. Par exemple, il est possible de changer de personnage (par exemple, quand un joueur meurt) sans perdre les données du joueur ou la logique de gestion des commandes, car ces éléments résident dans le ContrôleurDeJoueur.

Pour en savoir plus sur la configuration de ce contexte dans les blueprints, accédez au dossier Blueprints dans le navigateur de contenu, puis ouvrez le blueprint BP_FirstPersonPlayerController.

Les classes ContrôleurDeJoueur disposent d'un sous-système de joueur local de commandes avancé. Il s'agit d'un sous-système local associé à un joueur local spécifique. Il gère le contexte et les mappages de commande de ce joueur à l'exécution. Utilisez-le pour gérer les commandes actives et changer de contexte de commande à l'exécution. Pour plus d'informations sur les sous-systèmes de l'UE, consultez la page Programming Subsystems.

Lorsque le jeu commence, si le sous-système de joueur local de commandes avancé est valide, il appelle Add Mapping Context pour lier le contexte de mappage de commande IMC_Default au sous-système de commande du joueur. En d'autres termes, ce groupe de nœuds active cet ensemble de commandes pour le joueur.

Configurer votre classe de personnage 

Maintenant que vous avez vu comment le déplacement fonctionne dans les blueprints, il est temps de le construire en code, puis de tester les déplacements de votre personnage dans le niveau ! Vous commencerez par ajouter tous les modules et instructions #include nécessaires, puis vous déclarerez les classes, fonctions et propriétés nécessaires pour implémenter le déplacement des personnages.

Ajouter le système de commandes avancé

Vous vous êtes déjà assuré que le système de commandes avancé soit activé dans l'Unreal Editor, mais vous devrez également le déclarer manuellement dans le fichier Build.cs de votre projet et ajouter certains composants à la classe de personnage. 

Pour utiliser le système de commandes avancé dans votre projet C++, suivez les étapes ci-dessous :

1. Ouvrez votre projet dans Visual Studio et ouvrez [ProjectName].Build.cs (situé dans le dossier Source, avec les autres fichiers de classe de votre projet).   

   Ce fichier indique à l'Unreal Engine les modules dont vous avez besoin pour générer votre projet.

2. Dans l'appel de la fonction PublicDependencyModuleNames, ajoutez "EnhancedInput" à la liste des modules :    

   C++

   PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "EnhancedInput" });

   Copy full snippet(1 line long)

3. Enregistrez et fermez le fichier Build.cs.  

Pour ajouter des composants système de commandes avancé à votre classe de personnage, suivez les étapes ci-dessous :

1. Ouvrez le fichier .h de votre personnage. En haut du fichier, ajoutez les déclarations d'inclusion suivantes :

   • #include "EnhancedInputComponent.h" ajoute le module de composant de commandes avancé.  

   • #include "InputActionValue.h" permet d'accéder aux valeurs d'action de commande produites par vos actions de commandes.  

   • #include "EnhancedInputSubsystems.h" permet d'accéder au sous-système de joueur local.  

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Character.h"
   #include "EnhancedInputComponent.h"
   #include "EnhancedInputSubsystems.h" 
   #include "InputActionValue.h"
   #include "AdventureCharacter.generated.h"

   Copy full snippet(10 lines long)

   Assurez-vous que toutes les instructions #include que vous ajoutez viennent avant l'instruction AdventureCharacter.generated.h. Pour que la propriété Code to Function fonctionne, cette instruction doit apparaître en dernier dans la liste des commandes.  

2.   Après les déclarations #include, déclarez trois nouvelles classes :   

   • UInputMappingContext

   • UInputAction

   • UInputComponent

   Ces classes existent déjà dans le module de commandes avancé. Déclarer un objet existant de cette manière s'appelle une déclaration directe et cela indique au compilateur que la classe existe et que vous allez l'utiliser.  

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Character.h"
   #include "EnhancedInputComponent.h"
   #include "EnhancedInputSubsystems.h" 
   #include "InputActionValue.h"
   #include "AdventureCharacter.generated.h"
   
   Expand code Copy full snippet(14 lines long)

Déclarer un pointeur InputMappingContext

Dans la section protégée du fichier .h de votre personnage, utilisez TObjectPtr pour ajouter un nouveau pointeur UInputMappingContext appelé FirstPersonContext. Il s'agit d'un pointeur vers le contexte de mappage de commande qui associe vos actions de commandes aux pressions sur les boutons.

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
TObjectPtr<UInputMappingContext> FirstPersonContext;

La macro UPROPERTY(), placée avant la déclaration d'une variable informe l'Unreal Engine de l'existence de cette variable. L'outil Unreal Header utilise la macro pour traiter les informations relatives à votre code et contrôle l'accès à la variable, son apparence dans l'éditeur et bien plus encore.  

Ce pointeur a les valeurs UPROPERTY suivantes :

• EditAnywhere : expose la propriété dans l'Unreal Editor dans le panneau Details de la classe.

• BlueprintReadOnly : les blueprints peuvent accéder à cette propriété, mais pas la modifier.

• Category = Input : la propriété apparaîtra dans une section appelée Input dans le panneau Details de la classe. Les catégories sont utiles pour organiser votre code et peuvent faciliter la navigation dans l'éditeur.

Déclarer des pointeurs Jump et Move InputAction

Dans la section protégée, ajoutez deux pointeurs UInputAction nommés MoveAction et JumpAction. Ce sont des pointeurs vers les actions de commandes IA_Jump et IA_Move.

Appliquez-leur la même macro UPROPERTY() que UInputMappingContext. 

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
	TObjectPtr<UInputMappingContext> FirstPersonContext;

	// Move Input Actions
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
	TObjectPtr<UInputAction> MoveAction;

Déclarer la fonction Move()

Vos actions de commandes produisent des valeurs d'action de commande et vous transmettrez ces valeurs à une nouvelle fonction qui utilisera ces valeurs pour appliquer des déplacements à votre personnage.

Dans la section publique du fichier, déclarez une nouvelle fonction appelée Move() qui accepte une référence const FInputActionValue appelée Value.

// Handles 2D Movement Input
UFUNCTION()
void Move(const FInputActionValue& Value);

La macro UFUNCTION() qui vient avant la déclaration de la fonction rend l'outil Unreal Header conscient de la fonction.

Enregistrer le fichier. Le fichier d'en-tête de votre personnage devrait maintenant ressembler à ceci :

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"
#include "AdventureCharacter.generated.h"

class UInputMappingContext;

Implémenter les fonctions de déplacement

Maintenant que vous avez déclaré les propriétés nécessaires au déplacement de votre personnage, dans le fichier .cpp de votre personnage, vous allez créer vos fonctions pour imiter la fonctionnalité que vous avez vue dans le blueprint du personnage par défaut. 

Configurer la fonction Move()

Ouvrez le fichier .cpp de votre personnage et ajoutez une nouvelle fonction Move() pour implémenter celle que vous avez déclarée dans votre fichier .h. 

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
) 

En explorant les actions d'entrée du personnage par défaut, vous avez vu que le type de valeur d'IA_Move est Axis2D (Vector2D). Une valeur FVector2D est donc renvoyée en cas de déclenchement.

Dans Move(), obtenez la valeur de FInputActionValue et stockez-la dans un nouveau FVector2D appelé MovementValue :

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();
}

Ensuite, ajoutez une instruction if pour vérifier si Controller est valide. Controller est un pointeur vers le contrôleur qui possède cet acteur. Il doit être valide pour que le déplacement fonctionne. 

void AAdventureCharacter::Move(const FInputActionValue& Value)
{

	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();

	// Check if the controller possessing this Actor is valid
	if (Controller)
	{
	}

Ajouter une commande de déplacement 2D avec Move()

Pour produire des déplacements vers la gauche, la droite, l'avant et l'arrière dans le blueprint de personnage, le graphique d'événement a ajouté une commande de déplacement en combinant Action Value X et Action Value Y de IA_Move avec les vecteurs droit et avant de l'acteur. Vous implémenterez cela dans le code, dans la fonction Move().

Dans l'instruction if, appelez GetActorRightVector() pour stocker le vecteur droit de l'acteur dans un nouveau FVector nommé Right.

const FVector Right = GetActorRightVector();

Ensuite, appelez AddMovementInput() pour ajouter le déplacement au personnage en transmettant Right et MovementValue.X. 

AddMovementInput(Right, MovementValue.X);

Répétez ce processus pour les mouvements avant et arrière en utilisant GetActorForwardVector(), cette fois en transmettant MovementValue.Y.

Votre fonction Move() complète devrait ressembler à ceci :

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();

	// Check if the controller posessing this Actor is valid
	if (Controller)
	{
		// Add left and right movement
		const FVector Right = GetActorRightVector();

Lier le déplacement aux commandes avec SetupPlayerInputComponent

Associez maintenant votre fonction Move au contexte de mappage de commande FirstPersonContext que vous avez déclaré précédemment.

Le fonctionnement de SetupPlayerInputComponent() est déjà défini dans le fichier .cpp de votre personnage, car il est hérité de ACharacter. Cette fonction prend un UInputComponent et l'utilise pour configurer les commandes de joueur.

Chercher un composant de commandes avancé

Par défaut, cette fonction commence par un appel à la fonction SetupPlayerInputComponent() depuis ACharacter, qui vérifie si un composant de commande existe sur le personnage. 

// Called to bind functionality to input
void AAdventure::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
}

Cette option ne fait que vérifier si un composant de commande standard existe sur le personnage. Or, vous devez vérifier si un composant de commandes avancé est présent à la place. Supprimez donc cet appel à la fonction SetupPlayerInputComponent() de la classe parente.

Au lieu de cela, dans une instruction if, déclarez un nouveau pointeur UEnhancedInputComponent appelé EnhancedInputComponent. Affectez à cette variable le résultat de l'appel à CastChecked() sur PlayerInputComponent transmis à cette fonction lors de la conversion vers UEnhancedInputComponent.

if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
{

}

Lier des actions de déplacement

Dans l'instruction if, appelez la fonction BindAction() depuis EnhancedInputComponent. 

Transmettez les arguments suivants à la fonction : 

• MoveAction : action d'entrée à lier (déclarée dans le fichier .h du personnage).

• Événement Triggered issu de ETriggeredEvent : type de déclencheur de l'événement.

• this : personnage auquel l'action est liée.

• Move() : référence à la fonction que vous souhaitez lier.

if (TObjectPtr<UEnhancedInputComponent> EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
{
	// Bind Movement Actions
	EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Move);
}

Maintenant, quand IA_Move est déclenché, il appelle la fonction Move() pour ajouter le déplacement à votre personnage !

Lier des commandes de saut

Ajoutez ensuite deux liaisons à IA_Jump : une pour commencer le saut et une autre pour l'arrêter.

Vous utiliserez les arguments suivants :

• JumpAction, le pointeur d'action de commande vers IA_Jump que vous avez déclaré dans le fichier .h.

• Les événements de déclenchement Started et Completed.

• Les fonctions Jump et StopJumping héritées et définies dans la classe parente ACharacter.

// Bind Jump Actions
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &ACharacter::Jump);
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);

Votre fonction SetupPlayerInputComponent() devrait maintenant ressembler à ceci : 

// Called to bind functionality to input
void AAdventureCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	// Check the UInputComponent passed to this function and cast it to an UEnhancedInputComponent
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
	{
		// Bind Movement Actions
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Move);
		
		// Bind Jump Actions

Lier le mappage de commandes au personnage

Vous avez lié vos commandes à vos fonctions, mais vous devez encore lier le contexte de mappage de vos commandes à votre personnage. Vous effectuerez cette opération dans la fonction BeginPlay() de votre personnage pour que les commandes soient configurées quand le jeu démarrera.

Dans BeginPlay(), vérifiez si le pointeur global du moteur est null avant de continuer.

check(GEngine != nullptr);

Dans une instruction if, déclarez un nouveau pointeur APlayerController nommé PlayerController. Définissez cette valeur sur le résultat de la conversion de Controller en APlayerController.

// Get the player controller for this character
if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
{

}

L'instruction if assure que l'exécution ne se poursuit que si le pointeur n'est pas nul.

Maintenant, vous devez récupérer le sous-système de joueur local de commandes avancé et ajouter le contexte de mappage de commande FirstPersonContext (déclaré dans votre fichier .h). au sous-système.

Dans une autre instruction if, créez un nouveau pointeur UEnhancedInputLocalPlayerSubsystem nommé Subsystem en appelant ULocalPlayer::GetSubsystem() et en transmettant le joueur actuel. Vous pouvez obtenir le joueur actuel en appelant PlayerController->GetLocalPlayer().

if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
{
  if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
  {

  }
}

Ajoutez le contexte de mappage au sous-système en appelant AddMappingContext(), en transmettant le contexte de mappage et une priorité de 0 pour définir ce contexte de mappage en tant que priorité la plus élevée. 

// Get the enhanced input local player subsystem and add a new input mapping context to it
if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
{
	Subsystem->AddMappingContext(FirstPersonContext, 0);
}

Enfin, ajoutez un nouveau message de débogage pour vérifier que votre classe de personnage personnalisée est utilisée.

Votre fonction BeginPlay() doit ressembler à ceci :

// Called when the game starts or when spawned
void AAdventureCharacter::BeginPlay()
{
	Super::BeginPlay();

	check(GEngine != nullptr);

	// Get the player controller for this character
	if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
	{

Enregistrez vos fichiers d'en-tête .h et .cpp dans Visual Studio, puis cliquez sur Build pour compiler votre projet.

Définir des variables dans le blueprint de personnage

Pour finir de paramétrer ces contrôles de déplacement, utilisez le blueprints de votre personnage pour assigner des ressources aux variables que vous avez déclarées dans le code.

Pour renseigner les nouvelles propriétés de votre personnage avec des ressources, suivez ces étapes :

1. Dans l'Unreal Editor, s'il n'est pas déjà ouvert, ouvrez votre blueprint de personnage dans l'Éditeur de blueprint.

2. Dans le panneau Details, sous Input, définissez les propriétés suivantes :

   • Définissez Contexte à la première personne sur IMC_Adventure.

   • Définissez Move Action sur IA_Move.

   • Définissez Jump Action sur IA_Jump.

3. Enregistrez votre blueprint et cliquez sur Compile pour le compiler.

Tester le déplacement du personnage

Cliquez sur Jouer dans la barre d'outils de l'éditeur de niveau pour lancer le mode Play in Editor. Au lancement du jeu, "Hello world !" et "Nous utilisons AdventureCharacter" doivent s'afficher à l'écran. Vous devriez pouvoir vous déplacer en utilisant les touches WASD (QWERTY) ou les flèches et sauter avec la barre d'espace !

Suivant

Votre personnage se déplace, mais il lui manque un maillage et une caméra adéquats. Dans la prochaine section, vous apprendrez à créer un composant de caméra, à le lier à votre personnage et à ajouter des maillages squelettiques pour obtenir un vrai point de vue à la première personne !

Ajouter une caméra à la première personne, un maillage et une animation

Apprenez à utiliser C++ pour lier des composants de maillage et de caméra sur un personnage à la première personne.

Finaliser le code

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"
#include "AdventureCharacter.generated.h"

class UInputMappingContext;

#include "AdventureCharacter.h"

// Sets default values
AAdventureCharacter::AAdventureCharacter()
{
	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

}

// Fill out your copyright notice in the Description page of Project Settings.

using UnrealBuildTool;

public class AdventureGame : ModuleRules
{
	public AdventureGame(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;