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

Avant de commencer

Assurez-vous d'avoir terminé et atteint les objectifs suivants dans la section précédente, Configurer les déplacements du personnage :

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

• Configurer un personnage avec des déplacements avant, arrière, gauche, droite et saut.

Contrôles de caméra à la première personne

Pour modifier l'orientation de la caméra, on modifie la valeur de Rotation de la propriété Transform de la caméra. Pour pivoter dans un espace en 3D, les objets utilisent les fonctions Pitch, Roll et Yaw pour définir la direction et l'axe de rotation. 

• Pitch : contrôle la rotation le long de l'axe horizontal (X). Modifier cette propriété permet de faire pivoter l'objet vers le haut ou vers le bas, de la même manière que si on bouge la tête.

• Yaw : contrôle la rotation le long de l'axe vertical (Y). Modifier cette propriété permet de faire pivoter un objet vers la gauche ou la droite, de la même manière que pivoter vers la droite ou la gauche.

• Roll : contrôle la rotation le long de l'axe longitudinal (Z). Modifier cette propriété permet de faire pivoter un objet de chaque côté, de la même manière que quand on penche la tête vers la droite ou la gauche.

Dans les jeux à la première personne, les caméras utilisent généralement Yaw et Pitch pour contrôler le mouvement. Roll peut s'avérer utile si vous programmez un jeu dans lequel vous devez faire pivoter un avion ou un vaisseau spatial, ou si vous devez simuler un regard furtif dans les angles.

Découvrir le mouvement de caméra dans les blueprints

Ouvrez BP_FirstPersonCharacter pour visualiser la logique de contrôle de caméra du personnage par défaut dans l'Éditeur de blueprint. Dans le graphique d'événements, observez les deux nœuds dans l'angle supérieur gauche du groupe de nœuds Camera Input. 

Comme dans le cas de IA_Move, l'action d'entrée IA_Look est dotée d'un paramètre Type de valeur - Axe 2D qui divise le déplacement en valeurs X et Y. Cette fois, X et Y deviennent les entrées Lacet et Tangage de la fonction Visée personnalisée.

Double-cliquez sur le nœud de fonction Aim pour afficher la logique à l'intérieur. Les nœuds de fonction Add Controller Yaw Input et Pitch Input ajoutent les valeurs au personnage. 

Découvrir les composants de personnage à la première personne 

Accédez à l'onglet Viewport de BP_FirstPersonCharacter pour afficher un aperçu en 3D de l'acteur et de ses composants. 

Dans l'onglet Components, vous verrez une hiérarchie structurée de composants associés qui définissent le personnage dans le monde. 

Les blueprints de personnage sont automatiquement instanciés avec : 

• Un composant Capsule, qui permet au personnage d'entrer en collision avec les objets du monde.

• Un composant Maillage squelettique, qui permet les animations et sert à visualiser le personnage. Dans le panneau Details, vous verrez que ce personnage utilise SKM_Manny_Simple comme ressource de maillage squelettique.

• Le composant de déplacement de personnage qui permet au personnage de se déplacer.

Ce personnage a également un deuxième maillage squelettique nommé FirstPersonMesh (utilise également SKM_Manny_Simple), qui est un enfant du composant de maillage principal. Dans les jeux à la première personne, les personnages ont généralement des maillages distincts pour les contextes à la troisième personne et à la première personne. Le maillage à la troisième personne n'est visible que pour les autres joueurs ou lorsque le joueur est en vue à la troisième personne. Le maillage à la première personne est visible pour le joueur lorsqu'il est en vue à la première personne. 

Le composant FirstPersonMesh possède un Composant de caméra enfant appelé FirstPersonCamera. Cette caméra détermine la vue à la première personne du joueur et pivote avec le personnage lorsqu'il regarde autour de lui. Dans cette partie du tutoriel, vous allez utiliser C++ pour instancier une caméra sur votre personnage au moment de l'exécution et la positionner de façon à correspondre à la position de cette caméra. 

Pour plus d'informations sur les composants de personnage, consultez la documentation du framework de jeu des personnages.

Implémenter la commande de regard dans le code

Pour implémenter cette fonctionnalité de caméra dans le code, tout comme le déplacement que vous avez créé à l'étape précédente, vous devez lier l'action de commande IA_Look à une fonction, puis lier cette fonction à votre personnage. 

Déclarer les variables et la fonction Look()

Dans Visual Studio, ouvrez le fichier .h de votre personnage. 

Lorsque votre personnage est créé au moment de l'exécution, vous demandez à l'UE d'y ajouter un composant caméra et de positionner la caméra de façon dynamique. Pour activer cette fonctionnalité, ajoutez un nouveau #include pour "caméra/CameraComponent.h" :  

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

Dans la section protégée de l'en-tête, déclarez un nouveau pointeur UInputAction nommé LookAction. Utilisez la même macro UPROPERTY() pour ce pointeur que pour MoveAction et JumpAction. Cela pointera vers l'action de commande IA_Look.

// Look Input Actions
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
UInputAction* LookAction;

Dans la section publique, déclarez une nouvelle fonction appelée Look() qui accepte une référence const FInputActionValue appelée Value. Assurez-vous d'ajouter une macro UFUNCTION() à la fonction. 

// Handles Look Input
UFUNCTION()
void Look(const FInputActionValue& Value);

Après la déclaration de la fonction Look(), déclarez un nouveau pointeur UCameraComponent nommé FirstPersonCameraComponent. Pour exposer cette propriété dans l'Unreal Editor, ajoutez une macro UPROPERTY() avec les arguments VisibleAnywhere et Category = Camera pour qu'elle apparaisse dans la section Caméra du panneau Détails. 

// First Person camera
UPROPERTY(VisibleAnywhere, Category = Camera)
UCameraComponent* FirstPersonCameraComponent;

Déclarez un FVector appelé FirstPersonCameraOffset. Vous utiliserez ce décalage pour positionner correctement la caméra lorsque vous configurerez votre personnage. Initialisez-le sur un FVector avec les valeurs suivantes et les macros EditAnywhere et Category = Camera pour l'ajuster dans l'Unreal Editor si nécessaire.

// Offset for the first-person camera
UPROPERTY(EditAnywhere, Category = Camera)
FVector FirstPersonCameraOffset = FVector(2.8f, 5.9f, 0.0f);

Vous aurez besoin de quelques propriétés supplémentaires pour adapter l'apparence des objets rapprochés (comme le corps du personnage) dans la vue de la caméra. Déclarez les deux variables float suivantes.  

• FirstPersonFieldOfView : le champ de vision horizontal (en degrés) que cette caméra doit utiliser lors du rendu des composants de primitives balisées FirstPerson. Réglez le curseur sur 70.0f.  

• FirstPersonScale : l'échelle que cette caméra doit appliquer aux composants de primitives balisées FirstPerson. Réglez le curseur sur 0.6f.   

Attribuez à ces propriétés une macro UPROPERTY avec les spécificateurs EditAnywhere et Category = Camera.    

// First-person primitives field of view
UPROPERTY(EditAnywhere, Category = Camera)
float FirstPersonFieldOfView = 70.0f;

// First-person primitives view scale
UPROPERTY(EditAnywhere, Category = Camera)
float FirstPersonScale = 0.6f;

Enfin, déclarez un nouveau pointeur USkeletalMeshComponent appelé FirstPersonMeshComponent. Attribuez-lui une macro UPROPERTY() avec les arguments VisibleAnywhere et Category = Mesh. 

// First-person mesh, visible only to the owning player
UPROPERTY(VisibleAnywhere, Category = Mesh)
USkeletalMeshComponent* FirstPersonMeshComponent;

Vous avez maintenant configuré les déclarations des éléments suivants : 

• Maillage à la première personne (qui correspond au FirstPersonMesh enfant que vous avez vu dans le blueprint)

• Caméra

• Fonction Look()

• Action de commande IA_Look

Le fichier .h de votre personnage devrait maintenant ressembler à ceci :

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"

Ajouter une commande de regard avec Look()

Ouvrez le fichier .cpp de votre personnage pour implémenter la logique de commande de caméra du blueprint de personnage avec la fonction Look().

Tout comme IA_Move, IA_Look renvoie une valeur FVector2D lorsqu'elle est déclenchée. Ajoutez une nouvelle définition de fonction pour Look(). Dans la fonction, récupérez la valeur de la FInputActionValue dans un nouveau FVector2D appelé LookAxisValue.

void AAdventureCharacter::Look(const FInputActionValue& Value)
{
	const FVector2D LookAxisValue = Value.Get<FVector2D>();
}

Ensuite, dans une instruction if, vérifiez si le contrôleur est valide. 

Le cas échéant, appelez AddControllerYawInput() et AddControllerPitchInput() en transmettant les valeurs LookAxisValue.X et LookAxisValue.Y, respectivement. Votre fonction Look() complète devrait ressembler à ceci :

void AAdventureCharacter::Look(const FInputActionValue& Value)
{
	const FVector2D LookAxisValue = Value.Get<FVector2D>();

	if (Controller)
	{
		AddControllerYawInput(LookAxisValue.X);
		AddControllerPitchInput(LookAxisValue.Y);
	}
}

Lier la fonctionnalité de regard à une commande avec SetupPlayerInputComponent

Dans SetupPlayerInputComponent(), de la même manière que pour les actions de déplacement, vous liez la fonction Look() à l'action de commande LookAction. 

EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Look);

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, &AAdventurenCharacter::Move);

		// Bind Look Actions

Enregistrez votre code et compilez-le en cliquant sur Build dans Visual Studio. 

Affecter une action d'entrée d'apparence dans le blueprint

Enfin, affectez une action d'entrée à la nouvelle propriété Action d'apparence du blueprint du personnage.

Pour attribuer des contrôles d'apparence à votre personnage, procédez comme suit :

1. Ouvrez votre blueprint de personnage dans l'Unreal Editor.

2. Dans le panneau Composants, vérifiez que le composant racine BP_[CharacterName] est sélectionné.

3. Dans le panneau Détails, dans la section Commande, définissez Action d'apparence sur IA_Look.

   

4. Compilez et enregistrez votre blueprint.

Tester les mouvements de regard

Si vous cliquez sur Jouer pour tester votre jeu, vous pourrez regarder autour de vous et déplacer votre personnage dans la direction que vous souhaitez ! 

Notez que, bien que votre vue en jeu provienne de la caméra à la première personne, vous n'avez pas encore de composant de caméra sur votre personnage. L'Unreal Engine simule une vue depuis le centre du composant de capsule de votre personnage. Dans la prochaine étape, vous apprendrez à modifier ce paramètre en ajoutant une caméra à votre classe de Personnage .

Créer des composants au moment de l'exécution

Vous allez ensuite finir de créer le maillage et la caméra à la première personne de votre personnage en instanciant les pointeurs FirstPersonCameraComponent et FirstPersonMeshComponent que vous avez déclarés dans le fichier d'en-tête.

Pour commencer, ouvrez le fichier .cpp de votre personnage. 

En haut du fichier, vous verrez le constructeur de classe (AAdventureCharacter() dans ce tutoriel). Cette classe s'exécute lorsque l'objet est alloué en mémoire et définit les valeurs par défaut de votre personnage. C'est ici que vous ajoutez des composants. 

Créer un composant de caméra

Pour ajouter des composants au Personnage, vous utiliserez la fonction du modèle CreateDefaultSubobject(). Elle retourne un pointeur vers le nouveau composant et prend les arguments suivants :

CreateDefaultSubobject<type>(TEXT(“Name”));

Où type est le type de sous-objet que vous créez et Name est le nom interne utilisé par l'Unreal Engine pour identifier le sous-objet et l'afficher dans l'éditeur.

Dans le constructeur de classe, configurez le pointeur FirstPersonCameraComponent sur le résultat de l'appel de CreateDefaultSubobject() de type UCameraComponent. Dans l'argument TEXT, nommez l'objet "FirstPersonCamera". 

FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));

Cela crée un objet de caméra par défaut qui est un enfant de la classe Character.  Ensuite, pour assurer que la caméra a été correctement instanciée, vérifiez que FirstPersonCameraComponent n'est pas nul. 

// Create a first person camera component.
FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
check(FirstPersonCameraComponent != nullptr);

Créer un composant de maillage

Définissez FirstPersonMeshComponent sur un autre appel de fonction CreateDefaultSubobject. Cette fois, utilisez USkeletalMeshComponent en tant que type et "FirstPersonMesh" en tant que nom. N'oubliez pas d'ajouter une vérification par la suite.

// Create a first person mesh component for the owning player.
FirstPersonMeshComponent = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
	check(FirstPersonMeshComponent != nullptr);

Joindre et configurer le maillage 

Maintenant que votre maillage est créé, joignez-le au personnage et activez-y le rendu à la première personne. 

La fonction SetupAttachment() permet de joindre un composant de scène à un autre et d'établir une relation parent-enfant dans la hiérarchie des composants.   

Appelez la fonction SetupAttachment() sur l'objet vers lequel FirstPersonMeshComponent pointe et transmettez-lui le composant parent. Dans ce cas, le parent doit être le maillage squelettique par défaut du personnage, que vous pouvez obtenir en utilisant GetMesh(). 

// Attach the FirstPerson mesh to the Skeletal Mesh
FirstPersonMeshComponent->SetupAttachment(GetMesh());

Dans le fichier d'en-tête du personnage, vous avez déclaré un champ de vision et une échelle de caméra à utiliser pour les composants proches de la caméra. Pour appliquer ces propriétés de caméra au maillage à la première personne, définissez la propriété FirstPersonPrimitiveType du maillage sur FirstPerson. 

FirstPersonMeshComponent->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::FirstPerson;

Définir la visibilité du maillage

Votre personnage dispose donc de maillages squelettiques à la première et à la troisième personne qui se chevauchent pendant le gameplay. Cependant, le maillage à la première personne doit être invisible pour les autres joueurs, et le maillage à la troisième personne, pour vous, le joueur.

Pour configurer la visibilité du maillage et des ombres à la première et à la troisième personne, procédez comme suit : 

1. Dans le constructeur de classe du personnage, après avoir défini le type de primitive du maillage à la première personne, définissez le FirstPersonPrimitiveType du composant de maillage à la troisième personne sur WorldSpaceRepresentation.  

   C++

   GetMesh()->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::WorldSpaceRepresentation;
   

   Copy full snippet(1 line long)

   Ce type de primitive est destiné aux composants que les autres joueurs voient. La propriété OwnerNoSee de ce composant est automatiquement définie sur false, le rendant invisible pour le joueur. Cependant, le maillage projette toujours une ombre. 

2. Dans BeginPlay(), après la vérification globale du pointeur du moteur, appelez SetOnlyOwnerSee() sur FirstPersonMeshComponent, en transmettant la valeur true pour que le maillage à la première personne soit uniquement visible pour le joueur propriétaire.   

   C++

   // Only the owning player sees the first-person mesh
   FirstPersonMeshComponent->SetOnlyOwnerSee(true);

   Copy full snippet(2 lines long)

Joindre le composant de caméra

Dans le constructeur du personnage, utilisez un autre appel SetupAttachment() pour joindre le composant de caméra au maillage à la première personne. Cette fois, vous ajouterez une surcharge facultative pour spécifier un emplacement exact (un connecteur) sur le maillage où le composant doit être joint.

Le maillage SKM_Manny_Simple utilisé dans ce tutoriel dispose d'une collection de connecteurs (ou d'os) prédéfinis utilisés pour animation. Vous pouvez faire référence aux connecteurs dans le code en utilisant une chaîne FName. Il est préférable de placer la caméra près de la tête du personnage. Vous allez donc passer le nom de connecteur Head à SetupAttachment pour joindre la caméra à ce connecteur. On rapprochera la caméra des yeux du personnage ultérieurement.

// Attach the camera component to the first-person Skeletal Mesh.
FirstPersonCameraComponent->SetupAttachment(FirstPersonMeshComponent, FName("head"));

Pour plus d'informations sur les emplacements et la façon dont ils sont créés, consultez la page Connecteurs de maillage squelettique.

Configurer la caméra

Après avoir initialisé votre composant de caméra, vous l'avez joint au connecteur de tête du personnage. En revanche, la caméra est plus précise lorsqu'elle est placée sur les yeux du personnage. Par défaut, la caméra pointe également vers le bas. Vous devrez donc la faire pivoter derrière la tête du personnage.

Pour déplacer et faire pivoter la caméra en position, appelez SetRelativeLocationAndRotation(), en transmettant FirstPersonCameraOffset et un nouveau FRotator défini sur (0.0f, 90.0f, -90.0f). 

// Position the camera slightly above the eyes and rotate it to behind the player's head
FirstPersonCameraComponent->SetRelativeLocationAndRotation(FirstPersonCameraOffset, FRotator(0.0f, 90.0f, -90.0f));

Pour faire pivoter la caméra avec le personnage pendant le gameplay, définissez la propriété bUsePawnControlRotation de FirstPersonCameraComponent sur true. La caméra hérite ainsi de la rotation de son Pion parent. Ainsi, quand le personnage tourne, la caméra suit. 

// Enable the pawn to control camera rotation.
FirstPersonCameraComponent->bUsePawnControlRotation = true;

Pour finir, ajoutez le champ de vision à la première personne et le rendu d'échelle à la première personne à la caméra. Définissez les propriétés bEnableFirstPersonFieldOfView et bEnableFirstPersonScale du composant sur true. Ensuite, attribuez les valeurs de champ de vision et d'échelle par défaut que vous avez déclarées précédemment.  

// Enable first-person rendering and set default FOV and scale values
FirstPersonCameraComponent->bEnableFirstPersonFieldOfView = true;
FirstPersonCameraComponent->bEnableFirstPersonScale = true;
FirstPersonCameraComponent->FirstPersonFieldOfView = FirstPersonFieldOfView;
FirstPersonCameraComponent->FirstPersonScale = FirstPersonScale;

Le constructeur de votre personnage doit ressembler à ceci :

// 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;

	// Create a first person camera component
	FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
	check(FirstPersonCameraComponent != nullptr);

Enregistrez votre code et compilez en cliquant sur Build dans Visual Studio. 

Assigner les maillages dans l'Unreal Editor

Les Contrôles de votre caméra sont configurés, mais il vous reste une étape : utilisez l'éditeur pour ajouter les maillages squelettiques aux variables que vous avez déclarées dans le code. 

Pour ajouter un maillage squelettique à un blueprint de personnage, suivez les étapes ci-dessous :

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

2. Dans le panneau Composants, vérifiez que le composant racine BP_[CharacterName] est sélectionné.

3. Dans la section Maillage du panneau Détails, votre personnage dispose de deux créneaux SkeletalMeshAsset au lieu d'un, car vous avez créé le composant de maillage FirstPersonMeshComponent dans le code. Cliquez sur la flèche dans le menu menu déroulant de chaque propriété et sélectionnez SKM_Manny_Simple pour les deux maillages. 

   

   Lorsque vous définissez le FirstPersonMeshComponent, votre caméra doit se mettre en position derrière la tête du personnage.

4. Enregistrer votre blueprint et cliquer sur Compiler.

Si vous jouez à votre jeu et baissez les yeux, vous devriez voir le maillage à la première personne de votre Personnage ! Le maillage pivote lorsque vous regardez autour de lui, et votre caméra suit son déplacement. Le maillage à la troisième personne est masqué à l'exécution et seuls les autres joueurs peuvent le voir. Toutefois, étant donné que votre personnage est toujours dans une pose en T statique, utilisez un blueprint d'animation pour ajouter des animations à votre personnage et finir de lui donner vie !  

Ajouter des animations à votre Personnage

Dans le code, vous pouvez accéder à la logique animation via des instances de la classe UAnimInstance, qui est un contrôleur qui détermine les animations fusionnées et jouées sur un maillage squelettique en fonction de l'état et d'autres variables. Les blueprints d'animation dérivent également de UAnimInstance, et vous pouvez y faire référence en C++ avec le type UAnimBlueprint. 

La création d'une classe Instance d'animation n'entre pas dans le cadre de ce tutoriel ; vous allez plutôt ajouter le blueprint d'animation préconçu du modèle de première personne à votre Personnage. Ce blueprint inclut les animations et la logique dont votre Personnage a besoin pour jouer différentes animations de mouvement et de repos.

Dans l'Unreal Engine, les animations sont définies par maillage. Vous aurez donc besoin d'animations distinctes pour vos maillages à la première et à la troisième personne. Étant donné que votre maillage à la troisième personne est masqué lorsque le jeu commence, vous n'avez qu'à définir des animations pour le maillage à la première personne. 

Pour ajouter une propriété animation et un blueprint d'animation à votre Personnage, suivez ces étapes :

1. En haut du fichier .h de votre personnage, déclarer la classe UAnimBlueprint. Cette classe représente les blueprints d'animation du projet.

   C++

   class UAnimBlueprint;
   class UInputMappingContext;
   class UInputAction;
   class UInputComponent;

   Copy full snippet(4 lines long)

2. Ensuite, dans la section publique, déclarez un nouveau pointeur UAnimBlueprint nommé FirstPersonDefaultAnim. Ajoutez-lui la macro UCLASS(), avec EditAnywhere et Category = Animation.

   C++

   // First Person animations
   UPROPERTY(EditAnywhere, Category = Animation)
   UAnimBlueprint* FirstPersonDefaultAnim;

   Copy full snippet(3 lines long)

3. Dans le fichier .cpp de votre personnage, dans BeginPlay(), appelez FirstPersonMeshComponent->SetAnimInstanceClass(). Même si vous n'avez pas encore défini de classe d'instance d'animation dans le code, vous pouvez générer une classe à partir du blueprint d'animation à l'aide de GeneratedClass.

   C++

   // Only the owning player sees the first person mesh.
   FirstPersonMeshComponent->SetOnlyOwnerSee(true);
   
   // Set the animations on the first person mesh.
   FirstPersonMeshComponent->SetAnimInstanceClass(FirstPersonDefaultAnim->GeneratedClass);

   Copy full snippet(5 lines long)

4. Enregistrez votre code et compilez-le depuis Visual Studio.

5. Dans l'Unreal Editor, rouvrez votre classe de blueprint Character et sélectionnez le composant racine BP_[CharacterName].

6. Dans le panneau Détails, sous Animation, réglez l'option First Person Default Anim sur ABP_Unarmed.

   

7. Enregistrez votre blueprint et compilez-le.

Tester un Personnage

Cliquez sur Jouer pour tester le jeu. Si vous baissez la tête, vous verrez le maillage à la première personne s'animer lorsque vous bougez ! Essayez de vous déplacer et de sauter pour voir les différentes animations contrôlées par ce blueprint.   

Suivant

Dans la prochaine section, vous apprendrez à créer un objet que votre personnage pourra ramasser et utiliser !

Gérer les éléments et les données

Apprendre à utiliser les structures de données d'élément, les ressources de données et les tables de données pour définir des éléments et stocker et organiser leurs données à des fins d'évolutivité.

Code terminé

Voici le code complet généré dans cette section :

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"

#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;

	// Create a first-person camera component
	FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));