Design Patterns - eni - 9782409015823 -
Design Patterns 

Design Patterns
- Apprendre la conception de logiciels en réalisant un jeu vidéo (avec exercices et corrigés)

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, [...]
[lire le résumé du livre]

Auteur : 

Editeur : Eni

Collection : Ressources info

Date parution :

Reliure :
Broché
Nbr de pages :
700
Dimension :
17.8 x 21.6 x 2.2 cm
Poids :
1012 gr
ISBN 10 :
2409015824
ISBN 13 :
9782409015823
29,90 €
Disponible expédié
sous 4 à 8 jours

Paiements sécurisés
CB Google/Apple Pay, Chèque, Virement
0.01€ à partir de 35€ en France métropolitaine
Satisfait ou remboursé sous 14 jours ouvrés

Quel est le sujet du livre "Design Patterns"

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 œ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 !

Téléchargements

Auteurs :
Professeur des Universités à l'Ensea, Philippe-Henri Gosselin y est depuis plusieurs années responsable de la filière "Informatique et Système". Au sein de cette filière de spécialisation de dernière année d'ingénieur, il a mis en place une pédagogie par projet pour permettre aux étudiants de développer leurs compétences en informatique, autant sur le plan technique que méthodologique. A travers cet ouvrage, il a à cœur de proposer au lecteur une version étendue et généralisée de ces enseignements, qui ont fait leurs preuves auprès des étudiants.

En suivant ce lien, retrouvez tous les livres dans la spécialité Techniques de programmation.

Sommaire et contenu du livre "Design Patterns - - Apprendre la conception de logiciels en réalisant un jeu vidéo (avec exercices et corrigés)"

Avant-propos
  1. Objectifs
Concevoir une application d’envergure
  1. Le travail de conception : un gain de temps considérable
    1. 1. Un exemple simple
    2. 2. Diviser pour régner
    3. 3. Exemple d’amélioration
    4. 4. Approche Modèle-Vue-Contrôleur (MVC)
  2. Démarrage
    1. 1. Choix du jeu
    2. 2. Environnement de développement
      1. a. NetBeans avec EasyUML
      2. b. Autres environnements
    3. 3. Projets exemple
Représenter l’état du jeu
  1. Les données et leur représentation
    1. 1. Conception initiale
    2. 2. Types d’informations
    3. 3. Exemple avec le jeu Pacman
      1. a. Éléments fixes
      2. b. Éléments mobiles
    4. 4. Développement du jeu vidéo :cahier des charges
  2. Les informations élémentaires
    1. 1. Classes
      1. a. Créer un nouveau diagramme de classes avecNetBeans/EasyUML
      2. b. Ajout d’une classe
      3. c. Ajout d’une énumération
    2. 2. Hiérarchie de classes (polymorphisme)
      1. a. Classe mère
      2. b. Éléments statiques
      3. c. Accesseurs et mutateurs (getters et setters)
    3. 3. Combinaison de propriétés (Composition)
      1. a. Interfaces
      2. b. Composition
      3. c. Interfaces et Composition
    4. 4. Exercices
      1. a. Exercice : Jeu de rôle
      2. b. Exercice : Jeu de rôle avec classesmultiples
    5. 5. Développement du jeu vidéo :classes d’éléments
  3. Les conteneurs
    1. 1. Les listes et tableaux associatifs
      1. a. Listes
      2. b. Piles et files
      3. c. Tableaux associatifs
    2. 2. Contenir des éléments épars(Patron Décorateur)
    3. 3. Graphes d’éléments
    4. 4. Les tableaux multidimensionnels
    5. 5. Parcourir les conteneurs (Patron Itérateur)
    6. 6. Conteneur principal
    7. 7. Exercices
      1. a. Exercice : Civilization
      2. b. Exercice : Stellaris
    8. 8. Développement du jeu vidéo :les conteneurs
  4. Tests unitaires
    1. 1. Implanter des tests unitaires
      1. a. Génération des accesseurs/mutateurs(getters/setters)
      2. b. Générer le code source Java
      3. c. Écriture des tests unitaires
    2. 2. Exercices
      1. a. Exercice : Test de Civilization
      2. b. Exercice : Test de Stellaris
    3. 3. Développement du jeu vidéo :tests unitaires état
  5. Solutions exercices
    1. 1. Exercice 2.4.1 : Jeu de rôle
    2. 2. Exercice 2.4.2 : Jeu de rôleavec classes multiples
    3. 3. Exercice 3.7.1 : Civilization
    4. 4. Exercice 3.7.2 : Stellaris
    5. 5. Exercice 4.2.1 : Test de Civilization
    6. 6. Exercice 4.2.2 : Test de Stellaris
Interface utilisateur
  1. Interface utilisateur 2D avec AWT
    1. 1. Affichage synchrone en double tampon
      1. a. Afficher une fenêtre
      2. b. Création d’un canevas
      3. c. Double tampon et boucle principale (Patron Bouclede Jeu)
      4. d. Synchronisation
    2. 2. Affichage avec des tuiles
      1. a. Fabriquer un monde en tuiles
      2. b. Charger et afficher une image
      3. c. Dessiner avec des tuiles
      4. d. Dessiner un monde en tuiles
      5. e. Animations avec des tuiles
    3. 3. Contrôles
      1. a. Contrôles AWT (Patron Observateur)
      2. b. Clavier
      3. c. Souris
    4. 4. Optimisation de l’affichage
      1. a. Performance de l’affichage
      2. b. Utiliser un lanceur
  2. Interface utilisateur 3D avec LWJGL
    1. 1. Création d’une fenêtre
      1. a. Initialisation
      2. b. Exécution et destruction
    2. 2. Afficher un triangle
      1. a. Pipeline d’affichage
      2. b. Pipeline pour afficher un Triangle
      3. c. Gérer les Shaders
    3. 3. Coloriser et indexer
      1. a. Coloriser
      2. b. Indexer
      3. c. Exemple avec le dessin d’un disque
    4. 4. Perspective et contrôles
      1. a. Perspective
      2. b. Caméra
      3. c. Contrôles
    5. 5. Transformation et animations
      1. a. Transformer un objet
      2. b. Animation
    6. 6. Textures
      1. a. Charger une texture
      2. b. Utiliser la texture
  3. Conception logicielle
    1. 1. Abstraction de l’interface utilisateur
      1. a. Patron Façade
      2. b. Calques d’affichage (Patron Fabrique)
      3. c. Contrôles
    2. 2. Modes de jeu
      1. a. Abstraire la notion de mode de jeu (Patron Template)
      2. b. Changer de mode de jeu (Patron État)
      3. c. Proposer un menu
      4. d. Cacher les polices (Patron Poids-Mouche)
      5. e. Faire une suite de menus (Patron État)
    3. 3. Exercices
      1. a. Exercice 3.3.1 : Afficher du texte avec lafaçade
      2. b. Exercice 3.3.2 : Afficher une image avecla façade
      3. c. Exercice 3.3.3 : Détecter les séquencesde touches
  4. Développement du jeu vidéo : interface utilisateur
  5. Solutions des exercices
    1. 1. Exercice 3.3.1 : Afficher du texte avec lafaçade
    2. 2. Exercice 3.3.2 : Afficher une image avecla façade
    3. 3. Exercice 3.3.3 : Détecter les séquencesde touches
Moteur de jeu
  1. Approche générale
    1. 1. Présentation
    2. 2. Motivation
  2. Synchronisation entre état et interface utilisateur
    1. 1. Dessiner l’état du jeu
      1. a. Initialiser le monde (Patron Fabrique Abstraite)
      2. b. Définir le jeu de tuiles (Patron Poids-Mouche)
      3. c. Dessiner le monde contenu dans l’étatdu jeu
    2. 2. Déplacement et animations
      1. a. Déplacement des personnages
      2. b. Animations (Patron Composite)
    3. 3. Séparer état et rendu
      1. a. Rendre les animations indépendantes (PatronObservateur)
      2. b. Interpoler les déplacements
    4. 4. Exercices
      1. a. Exercice 2.4.1 : Fabriquer une galaxie
      2. b. Exercice 2.4.2 : Déplacer une armée
    5. 5. Développement du jeu vidéo :dessiner l’état
  3. Règles du jeu
    1. 1. Définir les règles du jeu
    2. 2. Exemple de définition de règlesavec le jeu Pacman
      1. a. Horloge globale
      2. b. Changements extérieurs
      3. c. Changements autonomes
      4. d. Fin de partie
    3. 3. Appliquer les règles (Patron Commande)
      1. a. Patron Commande
      2. b. Initialiser le jeu avec une commande
      3. c. Déplacer les personnages avec des commandes
      4. d. Implanter toutes les règles
    4. 4. Faire et défaire
      1. a. Défaire avec le patron Memento
      2. b. Défaire par compensation
    5. 5. Tester le moteur de règles
      1. a. Copier en profondeur (Patron Prototype)
      2. b. Comparer en profondeur
      3. c. Implanter les tests
    6. 6. Exercices
      1. a. Exercice 3.6.1 : Jouer à plusieurssur le même clavier
      2. b. Exercice 3.6.2 : Jeu de dames avec le patronCommande
      3. c. Développement du jeu vidéo :règles du jeu
  4. Fonctionnalités supplémentaires
    1. 1. Paramétrer une partie (Patron Constructeur)
    2. 2. Charger un niveau (Patron Visiteur)
    3. 3. Charger/sauvegarder l’étatdu jeu (Patron Proxy)
  5. Solutions des exercices
    1. 1. Exercice 2.4.1 : Fabriquer une galaxie
    2. 2. Exercice 2.4.2 : Déplacer une armée
    3. 3. Exercice 3.6.1 : Jouer à plusieurssur le même clavier
    4. 4. Exercice 3.6.2 : Jeu de dames avec le patronCommande
Intelligence Artificielle
  1. Préparation
    1. 1. État du jeu non modifiable
      1. a. Approche avec le Patron Proxy
      2. b. Approche avec le Patron Décorateur
    2. 2. Interface Intelligence Artificielle
      1. a. Dresser la liste des commandes possibles (Patron Stratégie)
      2. b. Comportement aléatoire
      3. c. Évaluation
    3. 3. Exercices
      1. a. Exercice 1.3.1 : Galaxie non modifiable
      2. b. Exercice 1.3.2 : Puissance 4 avec une IAsimple
    4. 4. Développement du jeu vidéo :préparation IA
  2. Intelligence Artificielle sans planification
    1. 1. Heuristique simple
    2. 2. Cartes de distance
      1. a. Rappels sur les graphes
      2. b. Calcul des cartes de distance
      3. c. Implantation
    3. 3. Gestion du calcul des cartes de distance
      1. a. Suivre un personnage
      2. b. Fournisseur de services
    4. 4. IA par comportement
      1. a. Principe
      2. b. Exemple avec Pacman
    5. 5. Exercices
      1. a. Exercice 2.5.1 : Plus court chemin dans lagalaxie
      2. b. Exercice 2.5.2 : Puissance 4 avec une IAheuristique
    6. 6. Développement du jeu vidéo :IA sans planification
  3. Intelligence Artificielle avec planification
    1. 1. Parcourir les états futurs
      1. a. Graphes d’états
      2. b. Les arbres de recherche
      3. c. Algorithmes de parcours
    2. 2. Minimax
      1. a. Version exhaustive
      2. b. Implantation
      3. c. Optimisation Alpha Bêta
      4. d. Validation avec le jeu du Morpion
      5. e. Application pour Pacman
    3. 3. Autres approches classiques en Intelligence artificielle
    4. 4. Exercices
      1. a. Exercice 3.4.1 : Parcours avec l’interfaceNode
      2. b. Exercice 3.4.2 : Puissance 4 avec une IAavec planification
    5. 5. Développement du jeu vidéo :IA avec planification
  4. Solution des exercices
    1. 1. Exercice 1.3.1 : Galaxie non modifiable
    2. 2. Exercice 1.3.2 : Puissance 4 avec une IAsimple
    3. 3. Exercice 2.5.1 : Plus court chemin dans lagalaxie
    4. 4. Exercice 2.5.2 : Puissance 4 avec une IAheuristique
    5. 5. Exercice 3.4.1 : Parcours avec l’interfaceNode
    6. 6. Exercice 3.4.2 : Puissance 4 avec une IAavec planification
Exécution concurrente et réseaux
  1. Exécution concurrente
    1. 1. Séparer Moteur de règles et Interfaceutilisateur
      1. a. Échanges entre les acteurs
      2. b. Thread du moteur de règles
      3. c. Transférer les commandes (Double Tampon)
      4. d. Mise à disposition du moteur et de l’état(Patron Observateur)
      5. e. Cacher les notifications
    2. 2. Paralléliser les traitements
      1. a. Appels asynchrones (Patrons Observateur et Futur)
      2. b. Patron Pool de threads
      3. c. Patron Producteur/Consommateur
      4. d. Parallélisation Minimax
    3. 3. Exercices
      1. a. Exercice 1.3.1 : Paralléliser larecherche exhaustive de collisions
      2. b. Exercice 1.3.2 : Paralléliser larecherche indexée de collisions
    4. 4. Développement du jeu vidéo :exécution concurrente
  2. Communication réseau
    1. 1. Notions essentielles
      1. a. Couches réseau
      2. b. Ethernet
      3. c. IP (Internet Protocol)
      4. d. UDP (User Datagram Protocol)
      5. e. TCP (Transmission Control Protocol)
      6. f. HTTP (Hypertext Transfer Protocol)
      7. g. API Web REST (Representational State Transfer)
      8. h. Formats de données
    2. 2. Implanter des services web
      1. a. Créer un serveur HTTP
      2. b. En-têtes HTTP et format des données
      3. c. Produire du JSON (Patrons Fabrique et Constructeur)
      4. d. Méthode HTTP et Client
      5. e. Service GET
      6. f. Service POST
    3. 3. Exercices
      1. a. Exercice 2.3.1 : Créer un chat avecdes sockets
      2. b. Exercice 2.3.2 : Implanter un mini serveurHTTP
  3. Jeu en réseau
    1. 1. Principes
    2. 2. Sérialiser les commandes
      1. a. Sérialisation
      2. b. Désérialisation
    3. 3. Rassembler les joueurs
      1. a. Définition du service
      2. b. Implantation des services
      3. c. Gestionnaire de services
      4. d. Serveur de services
      5. e. Requêtes depuis les clients
      6. f. Menus graphiques et requêtes réseau
    4. 4. Jeu multijoueur
      1. a. Implantation côté serveur
      2. b. Implantation côté client
      3. c. Améliorations
    5. 5. Exercices
      1. a. Exercice 3.5.1 : Multijoueur avec UDP
      2. b. Exercice 3.5.2 : Multijoueur sans étatlocal
    6. 6. Développement du jeu vidéo :jeu en réseau
  4. Solutions des exercices
    1. 1. Exercice 1.3.1 : Paralléliser larecherche exhaustive de collisions
    2. 2. Exercice 1.3.2 : Paralléliser larecherche indexée de collisions
    3. 3. Exercice 2.3.1 : Créer un chat avecdes sockets
    4. 4. Exercice 2.3.2 : Implanter un mini serveurHTTP
    5. 5. Exercice 3.5.1 : Multijoueur avec UDP
    6. 6. Exercice 3.5.2 : Multijoueur sans étatlocal

    Avis clients sur Design Patterns - eni - Ressources info

    (Ils sont modérés par nos soins et rédigés par des clients ayant acheté l'ouvrage)
    Donnez votre avis
     
    Controler les cookies