Chapitre 1.
Présentation d'Unreal Engine

__Exigences techniques
Exercice 1.01 : Création d’un projet Unreal Engine 5
__Exploration d'Unreal Engine
__Exploration de la fenêtre de l'éditeur
Navigation dans la fenêtre d'affichage
__Manipuler les acteurs
Exercice 1.02 : Ajout et suppression d’acteurs
Acteur de plan
Exercice 1.03 : Création d’un acteur Blueprint
__Exploration de l'éditeur de plans
__Exploration de la fenêtre du graphique d'événements
Exercice 1.04 : Création de variables de plan
Exercice 1.05 : Création d’une fonction Blueprint
Comprendre le nœud de multiplication
Exploration des événements __BeginPlay et Tick
____Exercice 1.06 : Déplacement de la classe TestActor le long de l’axe Z
Classe Blueprint de personnage à la troisième personne
__Exploration de l'utilisation des maillages et des matériaux
____message
____matériel
__Manipulation des matériaux dans UE5
Activité 1.01 : Déplacement du TESTATEUR le long de l’axe Z
__addition

Chapitre 2.
Travailler avec Unreal Engine

__Exigences techniques
__Créer et configurer un projet C++ vide
Exercice 2.01 : Création d’un projet C++ vierge
Structure du dossier de contenu d'Unreal Engine
__Utilisation des solutions Visual Studio
Débogage de code dans Visual Studio
Exercice 2.02 : Débogage de code de modèle à la troisième personne
Importer les ressources requises
Exercice 2.03 : Importation d’un fichier FBX de personnage
__Classe de modding de jeu Unreal
____Classe de base du mode de jeu
____Événement de jeu
Réseautage
____Comparaison de GameModeBase et GameMode
__Comprendre les niveaux et les plans de niveaux
____Unreal Phone Class
Classe de contrôleur de joueur Unreal
Exercice 2.04 : Configuration des modes de jeu, des manettes de joueurs et des téléphones
__Utilisation de l'animation
Plan d'animation
Graphique d'événements
____animation graphique
machine à états finis
Règles de transition
Espace de mélange
Exercice 2.05 : Création d’une animation de mannequin
Activité 2.01 : Ajouter une animation à un personnage
__addition

Chapitre 3.
Configuration des composants de classe de personnage et du blueprint

__Exigences techniques
__Classe de personnage irréelle
____Étendre la classe de personnage
Exercice 3.01 : Création et configuration d’une classe C++ de personnage à la troisième personne
__Étendre une classe C++ dans Blueprint
Exercice 3.02 : Extension des classes C++ avec des modèles
Activité 3.01 : Extension d’une classe de personnage C++ avec des Blueprints dans un projet d’animation
__addition

Chapitre 4.
Entrée du joueur

__Exigences techniques
__Comprendre les actions de saisie et le contexte de saisie
Exercice 4.01 : Création d’actions de mouvement et de saut
Gestion des entrées du joueur
Exercice 4.02 : Réception des actions de mouvement et de saut
Faites pivoter la caméra autour du personnage.
Activité 4.01 : Ajouter une logique de marche à votre personnage
__addition

Chapitre 5.
Gestion des collisions à l'aide de tracés de lignes

__Exigences techniques
__Présentation de Collision
__Paramètres du projet
Exercice 5.01 : Conversion du personnage de Dodgeball en vue de dessus
Comprendre le traçage de lignes
Création d'une classe C++ __EnemyCharacter
Exercice 5.02 : Création d’une fonction CanSeeActor effectuant un tracé de ligne
Visualisation des tracés de lignes
Exercice 5.03 : Création d’une fonction LookAtActor
Création d'une classe Blueprint __EnemyCharacter
__Traçage
Exercice 5.04 : Exécution d’un balayage
____Modifier la réaction de trace de visibilité
____Tracé multiligne
Canal de suivi de la caméra
Exercice 5.05 : Création d’un canal de traçage EnemySight personnalisé
Activité 5.01 : Création d’une propriété SightSource
__addition

Chapitre 6.
Configuration des objets de collision

__Exigences techniques
Collision entre objets dans UE5
Composant de collision
__Comprendre les événements de collision
__Comprendre les canaux de collision
Exercice 6.01 : Création d’une classe de balle au prisonnier
__Créer un matériau physique
Exercice 6.02 : Ajout d’un composant de mouvement de projectile à DodgeballProjectile
__Présentation d'une minuterie
Comprendre comment créer un acteur
Exercice 6.03 : Ajout de la logique de lancer de projectiles à la classe EnemyCharacter
Création d'une classe __Wall
Exercice 6.04 : Création d’une classe murale
__Créer une boîte à victoire
Exercice 6.05 : Création d’une classe VictoryBox
Exercice 6.06 : Ajout de fonctions d’accès à ProjectileMovementComponent à DodgeballProjectile
Activité 6.01 : Remplacer la fonction SpawnActor de EnemyCharacter par la fonction SpawnActorDeferred
__addition

Chapitre 7. Utilisation des utilitaires UE5

__Exigences techniques
Bonnes pratiques : accouplement lâche
Bibliothèque de fonctions __Blueprint
Exercice 7.01 : Déplacement de la fonction CanSeeActor vers la bibliothèque de fonctions Blueprint
Composant d'acteur
Exercice 7.02 : Création du composant d’acteur HealthComponent
Exercice 7.03 : Intégration du composant d’acteur HealthComponent
__Explorez l'interface
__Plan directeur des événements natifs
Exercice 7.04 : Création d’une classe HealthInterface
Activité 7.01 : Déplacement de la logique LookAtActor vers un composant d’acteur
__addition

Chapitre 8. Création d'interfaces utilisateur avec UMG

__Exigences techniques
__Interface utilisateur du jeu
__Bases de l'UMG
Exercice 8.01 : Création d’un modèle de widget
Présentation de l'ancre
Exercice 8.02 : Modification des ancres UMG
Exercice 8.03 : Création d’une classe C++ RestartWidget
Exercice 8.04 : Création de la logique pour ajouter le widget de redémarrage à l’écran
Exercice 8.05 : Configuration de la classe Blueprint DodgeballPlayerController
Comprendre la barre de progression
TP 8.06 : Ajout de logique C++ à la barre de santé
Activité 8.01 : Amélioration du widget de redémarrage
__addition

Chapitre 9.
Ajouter des éléments audiovisuels

__Exigences techniques
Audio dans __UE5
Exercice 9.01 : Importation de fichiers audio
Exercice 9.02 : Émettre un son à chaque fois que la balle touche une surface.
__Atténuation du son
Exercice 9.03 : Conversion du son lié en son 3D
Exercice 9.04 : Ajouter une musique de fond à votre jeu
__Comprendre les systèmes de particules
Exercice 9.05 : Création d’un système de particules lorsque la balle de dodgeball touche le joueur
Activité 9.01 : Jouer un son lorsque la balle au prisonnier touche le joueur
__Un aperçu de la conception des niveaux
Exercice 9.06 : Création d’un bloc de niveau
__Fonctionnalités supplémentaires
__addition

Chapitre 10.
Créer un jeu de plateforme à défilement latéral exceptionnel

__Exigences techniques
__Analyse de projet
__Personnage joueur
__Conversion d'un modèle à la troisième personne en un modèle à défilement latéral
Exercice 10.01 : Création d’un projet à défilement latéral et utilisation du composant de mouvement de personnage
Activité 10.01 : Faites sauter votre personnage plus haut
__Un aperçu des fonctionnalités du jeu de plateforme à défilement latéral.
____ personnage ennemi
____Power Up
Objets de collection
affichage tête haute
Exercice 10.02 : Ajustement des poids de l’éditeur de personnages et du squelette du mannequin par défaut
Activité 10.02 : Manipulation et animation du squelette
Comprendre l'animation dans Unreal Engine 5
____Squelette
____Maillage squelettique
Séquence d'animation
Exercice 10.03 : Importation et configuration des personnages et des animations
Activité 10.03 : Importez davantage d’animations personnalisées et vérifiez l’animation de course du personnage.
__addition

Chapitre 11.
Blendspace 1D, raccourcis clavier, machines à états

__Exigences techniques
__Créer un espace de mélange
Espace de fusion ____1D vs.
Espace de mélange général
Exercice 11.01 : Création d’un espace de fusion de mouvement de personnage 1D
Activité 11.01 : Ajout d’animations de marche et de course aux espaces Blend
Plan d'animation du personnage principal
Plan d'animation
Exercice 11.02 : Ajout d’espaces de fusion à un blueprint d’animation de personnage
__Qu'est-ce qu'un vecteur vitesse ?
Exercice 11.03 : Transmettre la variable de vitesse d’un personnage à un espace de mélange
Activité 11.02 : Aperçu de l’animation de course dans le jeu
Système de saisie amélioré
Exercice 11.04 : Ajout d’entrées pour le sprint
Exercice 11.05 : Réinitialisation de la classe parente d’un modèle de personnage
Exercice 11.06 : Programmation de la fonction de sprint de caractères
Activité 11.03 : Implémentation de l’entrée Throw
Machine à états d'animation
Exercice 11.07 : Machine à états de déplacement et de saut du personnage joueur
Règles de transition
Exercice 11.08 : Ajout de nouveaux états et de règles de transition à une machine à états.
Exercice 11.09 : Fonction de ratio du temps restant
Activité 11.04 : Compléter la machine à états de mouvement et de saut
__addition

Chapitre 12.
Fusion et montage d'animations

__Exigences techniques
__Fusion d'animations, emplacements d'animation, montages d'animations
Exercice 12.01 : Création d’un montage d’animation
Montage d'animation
Exercice 12.02 : Ajouter une animation de lancer à un montage
Gestionnaire de machines à sous __Anim
Exercice 12.03 : Ajout d’un nouvel emplacement d’animation
__Enregistrer la pose en cache
Exercice 12.04 : Sauvegarde de la pose mise en cache dans la machine à états de mouvement
Mélange stratifié par os
Exercice 12.05 : Fusion des emplacements d’animation et des animations du haut du corps
Exercice 12.06 : Aperçu de l’animation de lancer
L'ennemi des jeux de plateforme à défilement horizontal.
Exercice 12.07 : Création d’une classe C++ de base
Exercice 12.08 : Création et application de modèles d’animation d’ennemis
__Matériaux et instances de matériaux
Exercice 12.09 : Création et application d’instances de matériel ennemi
Activité 12.01 : Mise à jour des pondérations des mélanges
__addition

Chapitre 13.
Créer et ajouter une IA ennemie

__Exigences techniques
__ IA ennemie
Contrôleur IA
____Auto Possession IA
Exercice 13.01 : Implémentation d’un contrôleur d’IA
Message de navigation
Exercice 13.02 : Implémentation d’un volume de maillage de navigation pour les ennemis
__Refonte du maillage de navigation
Exercice 13.03 : Refonte des paramètres de volume du maillage de navigation
Activité 13.01 : Création d’un nouveau niveau
Arbre de comportement et tableau noir
____tâche
____Décorateur
____service
Exercice 13.04 : Création d’un arbre de comportement et d’un tableau noir pour l’IA
Exercice 13.05 : Création d’un arbre de comportement
Exercice 13.06 : Création d’une logique d’arbre de comportement
Activité 13.02 : L’IA se déplace vers l’emplacement du joueur
Exercice 13.07 : Création de positions de reconnaissance ennemies
__Conversion vectorielle
Exercice 13.08 : Sélection d’un emplacement aléatoire dans un tableau
Exercice 13.09 : Référence à l’acteur en position de reconnaissance
Exercice 13.10 : Mise à jour de BTTask_FindLocation
__Projectile du joueur
Exercice 13.11 : Création de projectiles pour les joueurs
Exercice 13.12 : Initialisation des paramètres de la classe PlayerProjectile
Activité 13.03 : Création d’un modèle de projectile pour le joueur
__addition

Chapitre 14.
Création de projectiles pour joueurs

__Exigences techniques
__Anim Notify et état de la notification d'animation
Exercice 14.01 : Création d’une classe UAnimNotify
Exercice 14.02 : Ajout d’une nouvelle notification au montage d’animation de lancer
__Lire le montage d'animation
____Lecture d'un montage d'animation dans Blueprint
____Lecture d'un montage d'animation en C++
Exercice 14.03 : Animations de lancer en C++
Exercice 14.04 : Création d’un point d’apparition de projectile
Exercice 14.05 : Préparation de la fonction SpawnProjectile()
Exercice 14.06 : Mise à jour de la classe Anim_ProjectileNotify
__Supprimer l'acteur
Exercice 14.07 : Création d’une fonction DestroyEnemy()
Exercice 14.08 : Retrait des projectiles
Activité 14.01 : Projectiles qui détruisent les ennemis
Effets visuels et effets audio
____Effets visuels
____Effets audio
Exercice 14.09 : Ajout d’effets lors de la destruction des ennemis
Exercice 14.10 : Ajout d’effets aux projectiles du joueur
Exercice 14.11 : Ajout de notifications VFX et SFX
Activité 14.02 : Ajout d’un effet lors de la destruction d’un projectile
__addition

Chapitre 15.
Objets de collection, objets d'amélioration et objets à ramasser

__Exigences techniques
Comprendre __URotatingMovementComponent
Exercice 15.01 : Création d’une classe d’acteur PickableActor_Base et ajout d’un composant URotatingMovementComponent
Activité 15.01 : Détection des chevauchements de joueurs et création d’effets dans PickableActor_Base
Exercice 15.02 : Création d’une classe PickableActor_Collectable
Activité 15.02 : Finir l’acteur à collectionner PickableActor
Affichage des variables à l'aide de __UE_LOG
Exercice 15.03 : Suivi du nombre de pièces collectées par un joueur
Présentation de l'interface utilisateur d'Unreal Motion Graphics
Comprendre le widget __Texte
____Ancre
Format du texte ____
Exercice 15.04 : Création d’un élément d’interface utilisateur pour compteur de pièces
__Ajout et création de widgets utilisateur UMG
Exercice 15.05 : Ajout d’une interface utilisateur de compteur de pièces à l’écran du joueur
Utilisation du __timer
Exercice 15.06 : Ajout d’un comportement de potion de puissance au joueur
Activité 15.03 : Création d’un acteur de potion de puissance
Exercice 15.07 : Création d’une classe de briques
Exercice 15.08 : Ajout de logique C++ à la classe Brick
__addition
__Défis supplémentaires

Chapitre 16.
Principes de base du multijoueur

__Exigences techniques
__Principes de base du multijoueur
Comprendre le serveur
Serveur dédié
Serveur d'écoute
Comprendre le client
Exercice 16.01 : Tester le modèle de vue à la troisième personne en multijoueur
__Emballage du projet
____Explorer les liens et la propriété
____Regardez le rouleau
Acteur créé sur le serveur
L'acteur est créé côté client.
Un pion appartenant au joueur est créé sur le serveur.
Un pion appartenant à un joueur est créé côté client.
Exercice 16.02 : Mise en œuvre de la notion de propriété et des rôles
Sortie de la fenêtre du serveur
____personnage du serveur
____Client 1 Personnage
Acteur de test de propriété
Sortie de la fenêtre du client 1
Comprendre la réplication des variables
Variables copiées
Exercice 16.03 : Réplication de variables à l’aide de Replicated, ReplicatedUsing, DOREPLIFETIME et DOREPLIFETIME_CONDITION
Sortie de la fenêtre du serveur
Sortie de la fenêtre du client 1
__Espace de fusion 2D
Exercice 16.04 : Création d’un espace de fusion 2D pour le mouvement
__Convertir ceci
Exercice 16.05 : Créer un personnage qui regarde vers le haut et vers le bas
Activité 16.01 : Création d’un personnage pour un projet de FPS multijoueur
__addition

Chapitre 17.
Utilisation des appels de procédure à distance

__Exigences techniques
__Comprendre les appels de procédure à distance
RPC du serveur
____RPC multicast
RPC client
Éléments à prendre en compte lors de l'utilisation de ____RPC
Exercice 17.01 : Utilisation des appels de procédure à distance
__Exposer les énumérations à l'éditeur
____TEnumAsByte
____UMETA
____Type de plan
Exercice 17.02 : Utilisation des énumérations C++ dans l’éditeur
Indexation de tableaux circulaires
Exercice 17.03 : Boucle d’énumération utilisant l’indexation circulaire bidirectionnelle des tableaux
Activité 17.01 : Ajout d’armes et de munitions à un jeu FPS multijoueur
__addition

Chapitre 18.
Utilisation des classes du framework de gameplay en multijoueur

__Exigences techniques
__Accéder aux classes du framework de gameplay en multijoueur
Exercice 18.01 : Affichage des valeurs d’instance du framework de gameplay
Sortie de la fenêtre du serveur
Fenêtre du client 1
__Utilisation du mode de jeu, de l'état du joueur et de l'état du jeu
____mode de jeu
État du joueur
____état du jeu
____Fonctionnalités intégrées utiles
Exercice 18.02 : Création d’un jeu multijoueur simple de ramassage d’objets
____Activité 18.01 : Mort, réapparition, tableau des scores, limite de victimes, dans les jeux FPS multijoueurs.
Ajouter ____élément
__addition

Ce que ce livre couvre

- Créez des personnages et des ennemis entièrement détaillés en vue à la troisième personne.
- Implémentation de la navigation dans les niveaux à l'aide du clavier, de la souris et de la manette
- Implémenter la logique du programme et les mécanismes du jeu en utilisant des effets de collision et de particules.
- Mise en œuvre de l'exploration par IA à l'aide de tableaux noirs et d'arbres de comportement
- Création d'animations de personnages à l'aide de plans d'animation et de montages d'animation
- Comment peaufiner votre jeu grâce à des effets visuels et sonores percutants
- Création d'une interface utilisateur de jeu de base utilisant un affichage tête haute (HUD).
- Comment implémenter le mode multijoueur dans un jeu

Public cible de ce livre

Ce livre s'adresse aux développeurs de jeux qui débutent avec Unreal Engine 5 pour leurs projets.
Cependant, il est également utile à ceux qui ont déjà utilisé Unreal Engine et qui souhaitent intégrer et améliorer leurs compétences.
Pour bien comprendre les concepts expliqués dans ce livre, vous devez posséder des connaissances de base en C++ et une compréhension des variables, des fonctions, des classes, du polymorphisme et des pointeurs.
Nous recommandons également un système Windows pour une compatibilité totale avec l'EDI utilisé dans le livre.

Structure de ce livre

Chapitre 1.
Dans « Présentation d'Unreal Engine », nous passons en revue l'éditeur d'Unreal Engine.
Ce cours présente l'interface de l'éditeur, explique comment manipuler les acteurs dans un niveau et aborde les bases de Blueprints, un langage de programmation visuelle.
Nous apprendrons également à créer des ressources matérielles utilisables dans vos maillages.
Chapitre 2.
Le module « Travailler avec Unreal Engine » présente les principes fondamentaux des jeux Unreal Engine, notamment la création d'un projet C++ et la configuration du dossier de contenu du projet.
Nous examinons également les contenus liés à l'animation.
Chapitre 3.
« Composants de classe de personnage et configuration du Blueprint » présente la classe Unreal Character, ainsi que les concepts d’héritage d’objets et la manière d’exploiter le mappage des entrées.
Chapitre 4.
Dans la section « Saisie du joueur », nous examinons la saisie du joueur.
Apprenez à utiliser le mappage d'actions et le mappage d'axes pour lier les pressions de touches ou les entrées tactiles à des actions en jeu, telles que sauter ou se déplacer.
Chapitre 5.
Dans « Gestion des collisions à l'aide de tracés de lignes », nous démarrons un nouveau projet appelé Dodgeball.
Dans ce chapitre, vous découvrirez le concept du traçage de lignes et les différentes manières dont cette technique peut être utilisée dans la création de jeux.

Chapitre 6.
Dans la section « Paramètres de collision des objets », nous apprenons à gérer les collisions entre objets.
Dans ce chapitre, vous découvrirez les composants de collision, les événements de collision et la simulation physique, ainsi que les minuteurs, les composants de mouvement des projectiles et les matériaux physiques.
Chapitre 7.
« Utilisation des utilitaires d'Unreal Engine 5 » explique comment implémenter certains utilitaires utiles pouvant être utilisés dans Unreal Engine.
Cela inclut des descriptions des composants des acteurs, des interfaces et des bibliothèques de fonctions de modèle.
Ces outils permettent aux autres membres de l'équipe de développement de maintenir le projet bien structuré et facilement accessible.
Chapitre 8.
« Créer des interfaces utilisateur avec UMG » explique l'interface utilisateur des jeux.
Apprenez à créer des menus et des HUD à l'aide d'UMG, le système d'interface utilisateur d'Unreal Engine.
Nous verrons également comment utiliser une barre de progression pour afficher la santé d'un personnage joueur.
Chapitre 9.
La section « Ajout d'éléments audiovisuels » présente les effets sonores et de particules d'Unreal Engine.
Apprenez à importer des fichiers audio dans votre projet, à les utiliser comme sons 2D et 3D et à ajouter des systèmes de particules existants à votre jeu.
Enfin, nous allons créer un nouveau niveau qui viendra compléter le projet Dodgeball en utilisant toutes les mécaniques de jeu que nous avons créées au cours des derniers chapitres.
Chapitre 10.
« Créer un jeu de plateforme à défilement latéral de qualité supérieure » ​​examine en détail les objectifs du projet SuperSideScroller et explique comment fonctionne l’animation dans Unreal Engine 5, avec des exemples de manipulation d’un squelette de mannequin basique.

Chapitre 11.
Dans « Utilisation de Blend Space 1D, des raccourcis clavier et des machines à états », vous apprendrez à utiliser Blend Space 1D, les machines à états d'animation et le système d'entrée amélioré d'Unreal Engine 5 pour créer une logique d'animation basée sur le mouvement pour un personnage joueur.
Chapitre 12.
Dans le module « Fusion et montage d'animations », vous découvrirez des concepts d'animation supplémentaires tels que la fusion et le montage d'animations dans Unreal Engine 5, permettant ainsi aux animations de se jouer simultanément lorsque le personnage du joueur se déplace et lance un projectile.
Chapitre 13.
Dans « Création et ajout d'IA ennemie », vous apprendrez à utiliser le contrôleur d'IA, le tableau noir et les arbres de comportement d'Unreal Engine 5 pour créer des fonctionnalités d'IA simples pour les ennemis que le joueur pourrait rencontrer.
Chapitre 14.
Dans le module « Création de projectiles pour le joueur », vous apprendrez à créer et à détruire des objets du jeu.
Nous verrons également comment utiliser des fonctionnalités d'animation supplémentaires telles que AnimNotify et AnimNotifyState pour créer des projectiles pour le joueur pendant les animations.
Chapitre 15.
Dans « Objets à collectionner, objets améliorés et objets à ramasser », nous présentons les concepts d'interface utilisateur UMG d'Unreal Engine 5 et créons des objets à collectionner et des objets améliorés pour les joueurs.

Chapitre 16.
« Les bases du multijoueur » explique le fonctionnement de l’architecture serveur-client et aborde des concepts multijoueurs tels que les connexions, la propriété des acteurs, les rôles et la réplication des variables.
Vous explorerez également les espaces de fusion 2D, créerez des grilles d'animation pour les mouvements bidimensionnels et apprendrez à modifier la transformation d'un os en cours d'exécution à l'aide de la commande Transform Modify Bone.
Chapitre 17.
Le document « Utilisation des appels de procédure distante » explique le fonctionnement des appels de procédure distante, les différents types d'appels de procédure distante et les éléments à prendre en compte lors de leur utilisation.
Nous montrons également comment exposer les énumérations à l'éditeur et comment itérer sur les tableaux dans les deux sens en utilisant l'encapsulation d'index de tableau.
Chapitre 18.
« Utilisation des classes du framework de gameplay en multijoueur » explique comment utiliser les classes les plus importantes du framework de gameplay en multijoueur.
Nous examinerons également les modes de jeu, les états des joueurs, les états du jeu et certaines fonctionnalités intégrées utiles du moteur.

Note de l'auteur

Écrit par quatre experts possédant une vaste expérience d'Unreal Engine, ce livre vous plongera non seulement dans les projets de jeux Unreal, mais vous aidera également à vous familiariser avec une variété de projets de production de jeux et vous guidera à travers la dernière version d'Unreal Engine.
En commençant par l'Unreal Editor, nous présenterons des concepts fondamentaux tels que les acteurs, les blueprints, l'animation, l'héritage et les entrées du joueur, avant de passer à la création du premier des trois projets : le jeu Dodgeball.
Dans ce processus, vous découvrirez des concepts tels que le tracé de lignes, les collisions, les projectiles, les interfaces utilisateur et les effets sonores, et vous apprendrez également à combiner différents concepts pour mettre en œuvre de nouvelles techniques.
Le second projet, un jeu à défilement latéral, permettra de mettre en œuvre des concepts tels que le mélange d'animations, l'IA des ennemis, l'apparition d'objets et les objets à collectionner.
Enfin, nous abordons les concepts fondamentaux de la création d'un environnement multijoueur à travers notre troisième projet : un jeu de tir à la première personne.
À la fin de ce livre, vous aurez une bonne compréhension de la manière de créer vos propres jeux en utilisant les différents outils fournis par les moteurs de jeu.

Note du traducteur

Ce livre couvre tout, des bases du développement de jeux avec Unreal Engine 5 à ses fonctionnalités multijoueurs, ce qui en fait un excellent ouvrage pour les lecteurs souhaitant apprendre Unreal Engine 5, des bases aux contenus avancés, en un seul volume.
Ce livre couvre tout, des notions essentielles d'utilisation d'Unreal Engine 5 aux fonctionnalités multijoueurs avancées.
Puisqu'il contient tout ce qu'il faut savoir pour devenir développeur Unreal Engine 5, je pense qu'il sera très utile non seulement aux développeurs en herbe qui souhaitent débuter avec Unreal Engine 5, mais aussi aux développeurs confirmés qui veulent se référer à chaque fonctionnalité d'Unreal Engine 5.
Lors de la traduction, je me suis efforcé de comprendre les intentions de l'auteur dans chaque phrase, mais il se peut que certaines parties n'aient pas été correctement comprises ou aient été traduites incorrectement.
Nous accordons une grande importance à tout commentaire concernant le livre, y compris toute suggestion d'erreur, et nous nous engageons à les utiliser comme référence pour corriger les erreurs et améliorer encore le livre.
Je tiens à exprimer mon amour à ma femme, qui me soutient toujours, et à mes enfants, qui grandissent en bonne santé, et je souhaite exprimer ma gratitude à Acorn Publishing pour m'avoir donné l'opportunité de traduire.