Share
Dans le premier billet de cette série, nous avons expliqué pourquoi la programmation orientée objet était utile pour le développement de jeux et appris à identifier les objets, leurs états et leurs comportements. Dans cet article, nous examinerons le principe spécifique de la programmation orientée objet cohésion et comment cela s'applique aux jeux.
Remarque: Bien que ce tutoriel ait été écrit en Java, vous devriez pouvoir utiliser les mêmes techniques et concepts dans presque tous les environnements de développement de jeux..
La cohésion est le principe d'être ou de bien faire une chose. En d’autres termes, cohésion signifie regrouper un code qui contribue à une tâche unique.
Un excellent exemple de ce principe hors programmation a été couvert dans l'un des premiers articles de Gamedevtuts + qui traitait de la règle d'action secrète:
N'essayez pas de créer trop de jeux dans un seul paquet… Individuellement, chacun de ces jeux aurait pu être bon. Ensemble, ils se sont battus.
La même règle s'applique à la programmation orientée objet. Chaque objet ne devrait avoir qu'une seule responsabilité. Chaque comportement de cet objet ne doit effectuer qu'une seule tâche. Pas plus que cela et vous aurez beaucoup plus de mal à modifier le code.
Code qui est organisé par fonctionnalité et ne fait qu’une tâche est dit avoir haute cohésion. Un code hautement cohérent est réutilisable, simple et facile à comprendre. Il crée également des objets petits et concentrés.
Le code qui est organisé arbitrairement et a plusieurs tâches est dit avoir faible cohésion. Un tel code est difficile à comprendre, à maintenir et à réutiliser, et est souvent complexe. Il crée également des objets volumineux et flous..
Avoir une cohésion élevée est généralement bon, alors que d'avoir une cohésion faible est généralement mauvais. Lorsque vous écrivez du code, efforcez-vous toujours de rédiger un code très cohérent.
Alors, comment appliquons-nous cela à la programmation orientée objet? Pour commencer, organiser le code en objets contribue à renforcer la cohésion du jeu en général. Cependant, chaque objet individuel devrait également avoir une grande cohésion. Reportons-nous à nos trois exemples pour voir comment cela fonctionne..
Rappelez-vous du dernier article que nous avons défini l'objet navire comme ayant des comportements de retournement, de déplacement et de tir.
Si nous devions écrire un seul morceau de code qui appliquait les trois comportements en même temps, cela deviendrait plutôt compliqué. Au lieu de cela, nous devrions séparer chaque comportement en ce que nous appelons des fonctions. Les fonctions nous permettent de séparer les fonctionnalités et de regrouper des codes similaires, contribuant ainsi à créer un code très cohérent..
En programmation, un objet est défini en créant une classe. En Java, une classe est codée comme suit:
/ ** * La classe de navire * / classe publique Navire / ** * Fonction - exécute le comportement (tâche) de retourner le navire * / public void rotation () // Code qui fait tourner le navire / ** * Fonction - exécute le comportement (tâche) de déplacer le navire * / public void move () // Code qui déplace le navire / ** * Function - exécute le comportement (tâche) de tirer avec le canon du navire * / public vide ( ) // Code qui fait que le navire tire une balle
Comme vous pouvez le constater, chaque comportement a sa propre fonction et le code est assez bien organisé, juste dans cette structure squelette..
Ne vous inquiétez pas trop de la syntaxe exacte pour l'instant; nous en discuterons plus en détail à mesure que nous avançons dans la série.Pour Tetris, rappelez-vous que les comportements d’un tétromino étaient en chute, en mouvement (latéraux) et en rotation. La structure de classe de base est la suivante:
/ ** * La classe Tetromino * / public class Tetromino / ** * Fonction - met à jour la position d'un Tetromino * / public void fall () // Code qui met à jour la position du Tetromino / ** * Fonction - déplace un Tetromino * / public void move () // Code qui déplace le Tetromino sur le côté / ** * Fonction - fait pivoter un Tetromino * / public void rotation () // Code qui fait pivoter le Tetromino de 90 degrés
Encore une fois, les comportements sont séparés dans leurs propres fonctions. Pour le tomber méthode, cependant, notez que la tâche est de mettre à jour la position du tetromino. C’est parce que le tétromino est toujours en train de tomber, aussi nous ne pouvons pas simplement faire en sorte que la tâche "provoque la chute du tétromino".
Au lieu de cela, un tetromino en chute ne fait que déplacer l'écran d'un certain nombre de lignes à la fois - nous devons donc mettre à jour la position du tétromino pour refléter cette vitesse de chute.
Pour l'objet fantôme ayant des comportements d'état changeant et en mouvement, nous devons faire un peu plus de travail pour le rendre très cohérent..
/ ** * La classe Ghost * / classe publique Ghost / ** * Fonction - déplace le fantôme * / public void move () (// Code qui déplace le fantôme dans la direction actuelle / ** * Fonction - modifie Ghost. direction * / public void changeDirection () // Code qui modifie la direction du Ghost / ** * Fonction - modifie la vitesse du Ghost * / public void changeSpeed () // Code qui modifie la vitesse du Ghost / ** * Fonction - changez la couleur Ghost * / public void changeColor () // Code modifiant la couleur du Ghost / ** * Fonction - changez l'état du fantôme * / public void changeState () // Code modifiant l'état du Ghost // Cette fonction aussi appellera les trois fonctions changeDirection, changeSpeed et changeColor
L'état Ghost a trois fonctions supplémentaires ajoutées: changer de direction, changer de couleur, et changeSpeed. Celles-ci ne figuraient pas dans notre liste de comportements d'origine car elles ne sont pas des comportements. Au lieu de cela, ces fonctions sont connues sous le nom de fonctions auxiliaires et sont là pour nous aider à maintenir une cohésion élevée.
Le changement d'état (ce qui se produit lorsque Pac-Man mange une pastille d'énergie) nécessite trois tâches différentes: virer au bleu profond, inverser la direction et se déplacer plus lentement. Pour maintenir la cohésion, nous ne souhaitons pas qu'une fonction exécute ces trois tâches. Nous les divisons en trois sous-tâches sur lesquelles la fonction fera appel pour mener à bien sa tâche principale..
L'utilisation du mot et en décrivant ce que fait un comportement / une fonction, cela signifie généralement que nous devrions créer plus d'une fonction.
La cohésion est le principe qui consiste à regrouper un code similaire et à s'assurer que chaque fonction n'exécute qu'une seule tâche. La cohésion aide à créer du code qui est maintenable et réutilisable.
Dans le prochain truc rapide, nous discuterons du principe de couplage et de son lien avec la cohésion. Suivez-nous sur Twitter, Facebook ou Google+ pour vous tenir au courant des derniers messages..
Accentsconagua