La conception logicielle n'est probablement pas le sujet en informatique qui a le plus la réputation d'être sexy, ni même intéressant. Le sujet est souvent enseigné de manière dogmatique, sans mise en pratique ou en perspective. Ce livre devrait réconcilier les plus déçus avec le sujet, grâce à son approche très pragmatique : concevoir un jeu assez simple, mais à l'aide de patrons de conception bien choisis. Ainsi, tous les exemples de l'ouvrage, à de rares exceptions près, tournent autour du jeu vidéo. Cette cohérence rend le tout motivant.
L'avantage principal de l'angle d'attaque utilisé est qu'il est foncièrement pratique, chaque patron de conception étant très brièvement présenté de manière abstraite. La plupart des explications concernent son utilisation réelle dans du code, ses interactions avec d'autres patrons. L'auteur part souvent d'un code simplement fonctionnel, sans conception poussée, avant d'introduire les quelques patrons appropriés. Le lecteur peut ainsi voir clairement l'effet structurant de chaque patron de conception, les situations dans lesquelles il peut être utile, mais aussi les avantages qu'il propose.
Pour arriver à ses fins, l'auteur suppose un certain niveau de programmation orientée objet impérative en Java, puis explique le reste. Il passe un certain temps à présenter AWT et LWJGL (OpenGL) pour l'interface graphique, par exemple. Il ne s'agit pas d'un survol accéléré ni d'une descente profonde, mais bien d'un niveau suffisant pour l'application visée (un simple Pacman, certes) et d'autres encore. Aussi, l'auteur présente des techniques de parallélisme (de manière assez générale, le sujet étant vital dans le développement de jeux), de communication en réseau (avec un focus sur les problématiques propres aux jeux, comme NAT et UDP) et d'intelligence artificielle, ainsi que les patrons de conception associés, sans présupposer de connaissances poussées dans ces domaines. Un regret, toutefois, est l'absence des systèmes à entités, un mécanisme de structuration très fort (notamment à l'œuvre dans Unity 3D), mais probablement un peu trop spécifique aux jeux.
En peu de mots, l'on peut dire que ce livre ne peut qu'être recommandé à ceux qui souhaitent débuter dans la conception logicielle, après avoir remarqué les limites des approches naïves. L'ouvrage sera plus difficilement utilisé comme une référence, même si chacun des vingt-trois patrons est présenté de manière abstraite à l'aide de diagrammes UML.
- Livres et vidéos
- Design Patterns - Apprendre la conception de logiciels en réalisant un jeu vidéo (avec exercices et corrigés)
Design Patterns Apprendre la conception de logiciels en réalisant un jeu vidéo (avec exercices et corrigés)
- Niveau Initié à Confirmé
- Nombre de pages 614 pages
- Parution octobre 2018
- Niveau Initié à Confirmé
- Parution octobre 2018
Le lecteur commence par découvrir le travail de conception, nécessaire avant de débuter le développement proprement dit, puis étudie plus précisément la manière de représenter l'ensemble des données utiles à la réalisation de l'application (classes, conteneurs...). L'auteur présente ensuite la notion d'interface utilisateur (en 2D et en 3D) pour le développement de l'affichage puis la mise en place du moteur du jeu vidéo (déplacements, animations, règles du jeu…). Les derniers chapitres sont ensuite consacrés à l'intégration de l'intelligence artificielle et au développement des fonctionnalités pour le jeu en réseau.
Les notions étudiées dans ce livre sont introduites et mises en œuvre pas à pas, des plus élémentaires au plus complexes, et permettent au lecteur d'acquérir la pratique nécessaire pour éviter les pièges usuels liés au développement d'une application d'envergure. L'auteur propose également une série d'exercices avec corrigés pour illustrer les différentes techniques étudiées.
Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Les chapitres du livre :
Avant-propos – Concevoir une application d'envergure – Représenter l'état du jeu – Interface utilisateur – Moteur de jeu – Intelligence artificielle – Exécution concurrente et réseaux
Quizinclus dans
la version en ligne !
- Testez vos connaissances à l'issue de chaque chapitre
- Validez vos acquis
Revue de presse
Ce livre s'adresse aux développeurs qui souhaitent acquérir des compétences dans le domaine de la conception logicielle en utilisant les patrons de conception (design patterns). L'approche suivie dans ce livre pour atteindre cet objectif est celle de la réalisation d'un jeu vidéo, développé à l'aide du langage Java. Seules des connaissances de base en programmation objet sont requises pour bien démarrer la lecture de ce livre. Le lecteur commence par découvrir le travail de conception, nécessaire avant de débuter le développement proprement dit, puis étudie plus précisément la manière de représenter l'ensemble des données utiles à la réalisation de l'application (classes, conteneurs...). L'auteur présente ensuite la notion d'interface utilisateur (en 2D et en 3D) pour le développement de l'affichage puis la mise en place du moteur du jeu vidéo (déplacements, animations, règles du jeu...). Les derniers chapitres sont ensuite consacrés à l'intégration de l'intelligence artificielle et au développement des fonctionnalités pour le jeu en réseau. Les notions étudiées dans ce livre sont introduites et mises en oeuvre pas à pas, des plus élémentaires au plus complexes, et permettent au lecteur d'acquérir la pratique nécessaire pour éviter les pièges usuels liés au développement d'une application d'envergure. L'auteur propose également une série d'exercices avec corrigés pour illustrer les différentes techniques étudiées.
Téléchargements
Concevoir une application d’envergure
- 1. Le travail de conception : un gain de temps considérable
- 1.1 Un exemple simple
- 1.2 Diviser pour régner
- 1.3 Exemple d’amélioration
- 1.4 Approche Modèle-Vue-Contrôleur (MVC)
- 2. Démarrage
- 2.1 Choix du jeu
- 2.2 Environnement de développement
- 2.2.1 NetBeans avec EasyUML
- 2.2.2 Autres environnements
- 2.3 Projets exemple
Représenter l’état du jeu
- 1. Les données et leur représentation
- 1.1 Conception initiale
- 1.2 Types d’informations
- 1.3 Exemple avec le jeu Pacman
- 1.3.1 Éléments fixes
- 1.3.2 Éléments mobiles
- 1.4 Développement du jeu vidéo : cahier des charges
- 2.1 Classes
- 2.1.1 Créer un nouveau diagramme de classes avec NetBeans/EasyUML
- 2.1.2 Ajout d’une classe
- 2.1.3 Ajout d’une énumération
- 2.2.1 Classe mère
- 2.2.2 Éléments statiques
- 2.2.3 Accesseurs et mutateurs (getters et setters)
- 2.3.1 Interfaces
- 2.3.2 Composition
- 2.3.3 Interfaces et Composition
- 2.4.1 Exercice : Jeu de rôle
- 2.4.2 Exercice : Jeu de rôle avec classes multiples
- 3.1 Les listes et tableaux associatifs
- 3.1.1 Listes
- 3.1.2 Piles et files
- 3.1.3 Tableaux associatifs
- 3.7.1 Exercice : Civilization
- 3.7.2 Exercice : Stellaris
- 4.1 Implanter des tests unitaires
- 4.1.1 Génération des accesseurs/mutateurs (getters/setters)
- 4.1.2 Générer le code source Java
- 4.1.3 Écriture des tests unitaires
- 4.2.1 Exercice : Test de Civilization
- 4.2.2 Exercice : Test de Stellaris
- 5.1 Exercice 2.4.1 : Jeu de rôle
- 5.2 Exercice 2.4.2 : Jeu de rôle avec classes multiples
- 5.3 Exercice 3.7.1 : Civilization
- 5.4 Exercice 3.7.2 : Stellaris
- 5.5 Exercice 4.2.1 : Test de Civilization
- 5.6 Exercice 4.2.2 : Test de Stellaris
Interface utilisateur
- 1. Interface utilisateur 2D avec AWT
- 1.1 Affichage synchrone en double tampon
- 1.1.1 Afficher une fenêtre
- 1.1.2 Création d’un canevas
- 1.1.3 Double tampon et boucle principale (Patron Boucle de Jeu)
- 1.1.4 Synchronisation
- 1.1 Affichage synchrone en double tampon
- 1.2 Affichage avec des tuiles
- 1.2.1 Fabriquer un monde en tuiles
- 1.2.2 Charger et afficher une image
- 1.2.3 Dessiner avec des tuiles
- 1.2.4 Dessiner un monde en tuiles
- 1.2.5 Animations avec des tuiles
- 1.3 Contrôles
- 1.3.1 Contrôles AWT (Patron Observateur)
- 1.3.2 Clavier
- 1.3.3 Souris
- 1.4 Optimisation de l’affichage
- 1.4.1 Performance de l’affichage
- 1.4.2 Utiliser un lanceur
- 2.1 Création d’une fenêtre
- 2.1.1 Initialisation
- 2.1.2 Exécution et destruction
- 2.2.1 Pipeline d’affichage
- 2.2.2 Pipeline pour afficher un Triangle
- 2.2.3 Gérer les Shaders
- 2.3.1 Coloriser
- 2.3.2 Indexer
- 2.3.3 Exemple avec le dessin d’un disque
- 2.4.1 Perspective
- 2.4.2 Caméra
- 2.4.3 Contrôles
- 2.5.1 Transformer un objet
- 2.5.2 Animation
- 2.6.1 Charger une texture
- 2.6.2 Utiliser la texture
- 3.1 Abstraction de l’interface utilisateur
- 3.1.1 Patron Façade
- 3.1.2 Calques d’affichage (Patron Fabrique)
- 3.1.3 Contrôles
- 3.2.1 Abstraire la notion de mode de jeu (Patron Template)
- 3.2.2 Changer de mode de jeu (Patron État)
- 3.2.3 Proposer un menu
- 3.2.4 Cacher les polices (Patron Poids-Mouche)
- 3.2.5 Faire une suite de menus (Patron État)
- 3.3.1 Exercice 3.3.1 : Afficher du texte avec la façade
- 3.3.2 Exercice 3.3.2 : Afficher une image avec la façade
- 3.3.3 Exercice 3.3.3 : Détecter les séquences de touches
- 5.1 Exercice 3.3.1 : Afficher du texte avec la façade
- 5.2 Exercice 3.3.2 : Afficher une image avec la façade
- 5.3 Exercice 3.3.3 : Détecter les séquences de touches
Moteur de jeu
- 1. Approche générale
- 1.1 Présentation
- 1.2 Motivation
- 2. Synchronisation entre état et interface utilisateur
- 2.1 Dessiner l’état du jeu
- 2.1.1 Initialiser le monde (Patron Fabrique Abstraite)
- 2.1.2 Définir le jeu de tuiles (Patron Poids-Mouche)
- 2.1.3 Dessiner le monde contenu dans l’état du jeu
- 2.1 Dessiner l’état du jeu
- 2.2 Déplacement et animations
- 2.2.1 Déplacement des personnages
- 2.2.2 Animations (Patron Composite)
- 2.3 Séparer état et rendu
- 2.3.1 Rendre les animations indépendantes (Patron Observateur)
- 2.3.2 Interpoler les déplacements
- 2.4 Exercices
- 2.4.1 Exercice 2.4.1 : Fabriquer une galaxie
- 2.4.2 Exercice 2.4.2 : Déplacer une armée
- 2.5 Développement du jeu vidéo : dessiner l’état
- 3.1 Définir les règles du jeu
- 3.2 Exemple de définition de règles avec le jeu Pacman
- 3.2.1 Horloge globale
- 3.2.2 Changements extérieurs
- 3.2.3 Changements autonomes
- 3.2.4 Fin de partie
- 3.3.1 Patron Commande
- 3.3.2 Initialiser le jeu avec une commande
- 3.3.3 Déplacer les personnages avec des commandes
- 3.3.4 Implanter toutes les règles
- 3.4.1 Défaire avec le patron Memento
- 3.4.2 Défaire par compensation
- 3.5.1 Copier en profondeur (Patron Prototype)
- 3.5.2 Comparer en profondeur
- 3.5.3 Implanter les tests
- 3.6.1 Exercice 3.6.1 : Jouer à plusieurs sur le même clavier
- 3.6.2 Exercice 3.6.2 : Jeu de dames avec le patron Commande
- 3.6.3 Développement du jeu vidéo : règles du jeu
- 4.1 Paramétrer une partie (Patron Constructeur)
- 4.2 Charger un niveau (Patron Visiteur)
- 4.3 Charger/sauvegarder l’état du jeu (Patron Proxy)
- 5.1 Exercice 2.4.1 : Fabriquer une galaxie
- 5.2 Exercice 2.4.2 : Déplacer une armée
- 5.3 Exercice 3.6.1 : Jouer à plusieurs sur le même clavier
- 5.4 Exercice 3.6.2 : Jeu de dames avec le patron Commande
Intelligence Artificielle
- 1. Préparation
- 1.1 État du jeu non modifiable
- 1.1.1 Approche avec le Patron Proxy
- 1.1.2 Approche avec le Patron Décorateur
- 1.1 État du jeu non modifiable
- 1.2 Interface Intelligence Artificielle
- 1.2.1 Dresser la liste des commandes possibles (Patron Stratégie)
- 1.2.2 Comportement aléatoire
- 1.2.3 Évaluation
- 1.3 Exercices
- 1.3.1 Exercice 1.3.1 : Galaxie non modifiable
- 1.3.2 Exercice 1.3.2 : Puissance 4 avec une IA simple
- 1.4 Développement du jeu vidéo : préparation IA
- 2.1 Heuristique simple
- 2.2 Cartes de distance
- 2.2.1 Rappels sur les graphes
- 2.2.2 Calcul des cartes de distance
- 2.2.3 Implantation
- 2.3.1 Suivre un personnage
- 2.3.2 Fournisseur de services
- 2.4.1 Principe
- 2.4.2 Exemple avec Pacman
- 2.5.1 Exercice 2.5.1 : Plus court chemin dans la galaxie
- 2.5.2 Exercice 2.5.2 : Puissance 4 avec une IA heuristique
- 3.1 Parcourir les états futurs
- 3.1.1 Graphes d’états
- 3.1.2 Les arbres de recherche
- 3.1.3 Algorithmes de parcours
- 3.2.1 Version exhaustive
- 3.2.2 Implantation
- 3.2.3 Optimisation Alpha Bêta
- 3.2.4 Validation avec le jeu du Morpion
- 3.2.5 Application pour Pacman
- 3.4.1 Exercice 3.4.1 : Parcours avec l’interface Node
- 3.4.2 Exercice 3.4.2 : Puissance 4 avec une IA avec planification
- 4.1 Exercice 1.3.1 : Galaxie non modifiable
- 4.2 Exercice 1.3.2 : Puissance 4 avec une IA simple
- 4.3 Exercice 2.5.1 : Plus court chemin dans la galaxie
- 4.4 Exercice 2.5.2 : Puissance 4 avec une IA heuristique
- 4.5 Exercice 3.4.1 : Parcours avec l’interface Node
- 4.6 Exercice 3.4.2 : Puissance 4 avec une IA avec planification
Exécution concurrente et réseaux
- 1. Exécution concurrente
- 1.1 Séparer Moteur de règles et Interface utilisateur
- 1.1.1 Échanges entre les acteurs
- 1.1.2 Thread du moteur de règles
- 1.1.3 Transférer les commandes (Double Tampon)
- 1.1.4 Mise à disposition du moteur et de l’état (Patron Observateur)
- 1.1.5 Cacher les notifications
- 1.1 Séparer Moteur de règles et Interface utilisateur
- 1.2 Paralléliser les traitements
- 1.2.1 Appels asynchrones (Patrons Observateur et Futur)
- 1.2.2 Patron Pool de threads
- 1.2.3 Patron Producteur/Consommateur
- 1.2.4 Parallélisation Minimax
- 1.3 Exercices
- 1.3.1 Exercice 1.3.1 : Paralléliser la recherche exhaustive de collisions
- 1.3.2 Exercice 1.3.2 : Paralléliser la recherche indexée de collisions
- 1.4 Développement du jeu vidéo : exécution concurrente
- 2.1 Notions essentielles
- 2.1.1 Couches réseau
- 2.1.2 Ethernet
- 2.1.3 IP (Internet Protocol)
- 2.1.4 UDP (User Datagram Protocol)
- 2.1.5 TCP (Transmission Control Protocol)
- 2.1.6 HTTP (Hypertext Transfer Protocol)
- 2.1.7 API Web REST (Representational State Transfer)
- 2.1.8 Formats de données
- 2.2.1 Créer un serveur HTTP
- 2.2.2 En-têtes HTTP et format des données
- 2.2.3 Produire du JSON (Patrons Fabrique et Constructeur)
- 2.2.4 Méthode HTTP et Client
- 2.2.5 Service GET
- 2.2.6 Service POST
- 2.3.1 Exercice 2.3.1 : Créer un chat avec des sockets
- 2.3.2 Exercice 2.3.2 : Implanter un mini serveur HTTP
- 3.1 Principes
- 3.2 Sérialiser les commandes
- 3.2.1 Sérialisation
- 3.2.2 Désérialisation
- 3.3.1 Définition du service
- 3.3.2 Implantation des services
- 3.3.3 Gestionnaire de services
- 3.3.4 Serveur de services
- 3.3.5 Requêtes depuis les clients
- 3.3.6 Menus graphiques et requêtes réseau
- 3.4.1 Implantation côté serveur
- 3.4.2 Implantation côté client
- 3.4.3 Améliorations
- 3.5.1 Exercice 3.5.1 : Multijoueur avec UDP
- 3.5.2 Exercice 3.5.2 : Multijoueur sans état local
- 4.1 Exercice 1.3.1 : Paralléliser la recherche exhaustivede collisions
- 4.2 Exercice 1.3.2 : Paralléliser la recherche indexée de collisions
- 4.3 Exercice 2.3.1 : Créer un chat avec des sockets
- 4.4 Exercice 2.3.2 : Implanter un mini serveur HTTP
- 4.5 Exercice 3.5.1 : Multijoueur avec UDP
- 4.6 Exercice 3.5.2 : Multijoueur sans état local
- Index