1ereNSI/representation_construits/evaluation/TP06_Pokemon_aide.md

# Aide - TP06 Pokemon

## Rappels utiles

### Structure des tuples Pokemon
```python
# Pokemon = (nom, types, pv, attaque, defense, vitesse, evolution)
pokemon = pokedex[0]
nom = pokemon[0]         # "Bulbizarre"
types = pokemon[1]       # ("Plante", "Poison")
pv = pokemon[2]          # 45
attaque = pokemon[3]     # 49
defense = pokemon[4]     # 49
vitesse = pokemon[5]     # 45
evolution = pokemon[6]   # "Herbizarre"
```

### Types multiples
```python
pokemon = pokedex[5]  # Dracaufeu
# types est un tuple : ("Feu", "Vol")
print(pokemon[1][0])  # "Feu" (type principal)

if "Feu" in pokemon[1]:
    print("C'est un type Feu")
```

---

## Exercice 1

### 1.1 - Affichage Pokemon
```python
def afficher_pokemon(pokemon):
    nom = pokemon[0]
    types = pokemon[1]
    pv = pokemon[2]
    attaque = pokemon[3]
    defense = pokemon[4]
    vitesse = pokemon[5]
    evolution = pokemon[6]

    # Afficher les types
    if len(types) == 2:
        types_str = types[0] + "/" + types[1]
    else:
        types_str = types[0]

    print(nom, "(", types_str, ")")
    print("PV:", pv, "| ATK:", attaque, "| DEF:", defense, "| VIT:", vitesse)

    if evolution == None:
        print("Evolution: Forme finale")
    else:
        print("Evolution:", evolution)
```

### 1.2 - Recherche par type
```python
def pokemon_par_type(dex, type_recherche):
    resultat = []
    for p in dex:
        if type_recherche in p[1]:  # p[1] = types
            resultat.append(p)
    # Trier par PV (indice 2) decroissants
    resultat = sorted(resultat, key=lambda p: p[2], reverse=True)
    return resultat
```

### 1.3 - Compter les types
```python
def compter_types(dex):
    compteur = {}
    for pokemon in dex:
        types = pokemon[1]
        for t in types:
            if t not in compteur:
                compteur[t] = 0
            compteur[t] = compteur[t] + 1
    return compteur
```

---

## Exercice 2

### 2.1 - Charger equipe
```python
def charger_equipe(noms, dex):
    equipe = []
    for nom_recherche in noms:
        # Chercher le pokemon dans le pokedex
        for pokemon in dex:
            if pokemon[0] == nom_recherche:
                equipe.append(pokemon)
                break
    return equipe
```

### 2.2 - Force de l'equipe
```python
def force_equipe(equipe):
    force_totale = 0
    for pokemon in equipe:
        pv = pokemon[2]
        attaque = pokemon[3]
        defense = pokemon[4]
        vitesse = pokemon[5]
        force_pokemon = pv + attaque + defense + vitesse
        force_totale = force_totale + force_pokemon
    return force_totale
```

### 2.3 - Pokemon le plus fort
```python
def plus_fort(equipe):
    if len(equipe) == 0:
        return None

    meilleur = equipe[0]
    meilleure_attaque = equipe[0][3]  # indice 3 = attaque

    for pokemon in equipe:
        if pokemon[3] > meilleure_attaque:
            meilleur = pokemon
            meilleure_attaque = pokemon[3]

    return meilleur
```

### 2.4 - Types couverts
```python
def types_couverts(equipe):
    types_liste = []
    for pokemon in equipe:
        types = pokemon[1]
        for t in types:
            if t not in types_liste:
                types_liste.append(t)
    return types_liste
```

---

## Exercice 3 (Bonus)

### 3.1 - Chaine d'evolution
```python
def chaine_evolution(nom, dex):
    chaine = [nom]

    # Chercher le pokemon actuel
    pokemon_actuel = None
    for p in dex:
        if p[0] == nom:
            pokemon_actuel = p
            break

    if pokemon_actuel == None:
        return chaine

    # Suivre les evolutions
    evolution = pokemon_actuel[6]
    while evolution != None and evolution != "Multiple":
        chaine.append(evolution)
        # Chercher le pokemon suivant
        for p in dex:
            if p[0] == evolution:
                evolution = p[6]
                break

    return chaine
```

### 3.2 - Verifier efficacite
```python
def est_efficace(attaquant, defenseur, faiblesses):
    types_attaquant = attaquant[1]
    types_defenseur = defenseur[1]

    # Pour chaque type de l'attaquant
    for type_att in types_attaquant:
        # Verifier si ce type est efficace
        if type_att in faiblesses:
            types_faibles = faiblesses[type_att]
            # Verifier si le defenseur a un type faible
            for type_def in types_defenseur:
                if type_def in types_faibles:
                    return True

    return False
```

### 3.3 - Meilleur contre un adversaire
```python
def meilleur_contre(adversaire, equipe, faiblesses):
    # D'abord chercher un pokemon efficace
    for pokemon in equipe:
        if est_efficace(pokemon, adversaire, faiblesses):
            return pokemon

    # Sinon renvoyer le plus fort en attaque
    return plus_fort(equipe)
```

---

## Pieges a eviter

1. **Types en tuple** : meme un seul type est un tuple `("Feu",)` - notez la virgule !
2. **Tuples immutables** : vous ne pouvez pas modifier `pokemon[2] = 50`
3. **Faiblesses unidirectionnelles** : Feu bat Plante, mais Plante ne bat pas Feu
4. **PV negatifs** : verifiez `pv > 0` et non `pv >= 0`
5. **Acces par indice** : pokemon[0]=nom, pokemon[1]=types, pokemon[2]=pv, pokemon[3]=attaque, pokemon[4]=defense, pokemon[5]=vitesse, pokemon[6]=evolution