Aller au contenu

Classes et responsabilités

Une classe regroupe des données et les fonctions qui les manipulent. Ce cours explique comment décider ce qui va dans une classe, et quoi faire quand elle a trop grossi.

Le problème

Dans le jeu, ButtonHandler dépasse 1 000 lignes et Map 650. Quand on cherche où se trouve une règle, on ne sait pas dans laquelle regarder, et la réponse est parfois « les deux ».

Map contient :

Python
def find_neighbors(self, coo): ... # mathématiques def organic_tiles(self): ... # génération def zoom_camera(self, event): ... # caméra def draw_tiles(self): ... # affichage def make_city(self): ... # règle du jeu

Cinq sujets sans rapport, réunis parce qu'ils « concernent la carte ».

La notion : une seule responsabilité

Le principe s'énonce ainsi : une classe ne devrait avoir qu'une seule raison de changer.

On teste en posant la question : « pour quelles raisons vais-je devoir modifier cette classe ? »

Raison de modifier MapQui le demande
Changer la forme des continentsCelui qui règle la génération
Rendre le zoom plus fluideCelui qui s'occupe du confort de jeu
Changer la couleur du brouillardCelui qui fait le graphisme
Interdire les villes trop prochesCelui qui équilibre les règles

Quatre raisons, quatre personnes différentes en théorie : quatre classes.

Reconnaître une classe trop grosse

SigneDans le jeu
Plusieurs centaines de lignesButtonHandler, Map
Le nom contient Handler, Manager, UtilsButtonHandler, PlayerHandler, Saves_Handler
On décrit son rôle avec « et »« Map génère la carte et gère la caméra et dessine »
Des groupes de méthodes n'utilisent pas les mêmes attributsLes méthodes de caméra ne touchent jamais aux biomes
Beaucoup d'attributsMap en a plus de vingt

Le quatrième signe est le plus fiable. Si l'on peut tracer une frontière entre deux groupes de méthodes et d'attributs qui ne se parlent pas, ce sont deux classes.

Découper : la méthode

  1. Lister les méthodes de la classe.

  2. Les regrouper par sujet. Un mot par groupe.

  3. Noter les attributs que chaque groupe utilise.

  4. Extraire le groupe le plus indépendant dans une nouvelle classe. L'ancienne en garde une instance.

  5. Vérifier que tout marche, faire un commit, recommencer.

Exemple avec la caméra :

Python
class Camera: def __init__(self, screen_w, screen_h): self.center = (0, 0) self.zoom = 1.75 self.screen_w = screen_w self.screen_h = screen_h def to_pixels(self, coo): ... def to_coo(self, pixel): ... def zoom_by(self, amount): ... def move(self, dx, dy): ...
Python
class Map: def __init__(self, game): self.camera = Camera(game.w, game.h)

Camera n'a besoin ni des cases ni des joueurs. On peut la tester seule.

Héritage ou composition

Deux façons de relier des classes.

HéritageComposition
Se dit« est un »« possède un »
S'écritclass Settler(Unit)self.camera = Camera()
Bon usageUne vraie variante de la même choseAssembler des pièces

Quand l'héritage va bien

Python
class Settler(Unit): ...

Un colon est une unité. Tout ce qu'une unité sait faire, il le fait.

Quand l'héritage va mal

Python
class City(Unit): ... class Farm(Unit): ...

Une ville n'est pas une unité : elle ne se déplace pas, n'attaque pas en bougeant. Elle hérite pourtant de move(), attack(), path_finding(). Le projet contourne le problème en mettant son mouvement à 0, et a besoin d'une fonction pour distinguer les deux :

Python
def find_if_is_unit_or_building(self, name): units = ["unit", "settler"] buildings = ["city"]

Devoir écrire une fonction qui demande à un objet ce qu'il est vraiment est un signe que la hiérarchie ne correspond pas à la réalité.

Quand il ne faut pas de classe du tout

Farm ne contient rien de plus que Unit : seules ses statistiques diffèrent. Créer une classe par bâtiment oblige à écrire du code pour chaque ajout. Une table de données suffit :

Python
BUILDINGS = { "farm": {"hp": 30, "income": {"food": 3}}, "quarry": {"hp": 40, "income": {"rock": 2}}, } building = Building(kind="farm", coo=(3, 4), owner_id="1")

Règle pratique : une classe quand le comportement change, une donnée quand seuls les nombres changent.

Les dataclass : des classes de données sans effort

Pour une classe qui sert surtout à ranger des valeurs, Python fournit un raccourci :

Python
from dataclasses import dataclass @dataclass class Tile: coo: tuple terrain: str owner_id: str | None = None

Python écrit __init__ à notre place, ainsi qu'un affichage lisible et la comparaison. On remplace ainsi les tuples lus par position, comme unit_data[2], par des noms : unit.hp.

À retenir

  • Une classe, une raison de changer.
  • Des groupes de méthodes qui ne partagent pas d'attributs sont des classes séparées.
  • Héritage pour « est un », composition pour « possède un ».
  • Si seuls les nombres changent, pas besoin d'une nouvelle classe.

Exercices

  1. Lister les méthodes de Map et les ranger en groupes. Combien en trouvez-vous ?
  2. Extraire la classe Camera de Map, sans changer le comportement du jeu.
  3. Créer une classe Building, faire hériter City et Farm, et supprimer find_if_is_unit_or_building en utilisant isinstance.
  4. Transformer le tuple renvoyé par Unit.get_unit_data en dataclass.