# 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 `Map` | Qui le demande |
| --- | --- |
| Changer la forme des continents | Celui qui règle la génération |
| Rendre le zoom plus fluide | Celui qui s'occupe du confort de jeu |
| Changer la couleur du brouillard | Celui qui fait le graphisme |
| Interdire les villes trop proches | Celui qui équilibre les règles |

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

## Reconnaître une classe trop grosse

| Signe | Dans le jeu |
| --- | --- |
| Plusieurs centaines de lignes | `ButtonHandler`, `Map` |
| Le nom contient `Handler`, `Manager`, `Utils` | `ButtonHandler`, `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 attributs | Les méthodes de caméra ne touchent jamais aux biomes |
| Beaucoup d'attributs | `Map` 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.

<Mermaid
  chart={`flowchart TB
    subgraph map [Map aujourd'hui]
      direction LR
      subgraph g1 [Caméra]
        a1[camera_center]
        a2[tile_number_factor]
        m1[zoom_camera]
        m2[move_camera]
      end
      subgraph g2 [Génération]
        b1[tiles_frequences]
        b2[layer_number]
        m3[layers]
        m4[organic_tiles]
      end
      subgraph g3 [Sélection]
        c1[selected_tile]
        c2[current_construction]
      end
    end
    g1 --> x1[Camera]
    g2 --> x2[MapGenerator]
    g3 --> x3[UiState]`}
/>

## Découper : la méthode

<Stepper>

1. **Lister les méthodes** de la classe.

1. **Les regrouper par sujet.** Un mot par groupe.

1. **Noter les attributs** que chaque groupe utilise.

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

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

</Stepper>

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éritage | Composition |
| --- | --- | --- |
| Se dit | « est un » | « possède un » |
| S'écrit | `class Settler(Unit)` | `self.camera = Camera()` |
| Bon usage | Une vraie variante de la même chose | Assembler 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é.

<Mermaid
  chart={`classDiagram
    direction LR
    class Entity {
      +owner_id
      +coo
      +hp
    }
    class Unit {
      +movement
      +move()
      +attack()
    }
    class Building {
      +level
      +income
    }
    Entity <|-- Unit
    Entity <|-- Building
    Unit <|-- Settler
    Unit <|-- Warrior
    Building <|-- City
    Building <|-- Farm`}
/>

### 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`.
