{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP Évaluation - Pokédex\n",
    "\n",
    "**Durée : 1h30**\n",
    "\n",
    "**Nom :** \n",
    "\n",
    "**Prénom :**\n",
    "\n",
    "---\n",
    "\n",
    "Dans ce TP, vous allez créer un système de gestion de Pokédex.\n",
    "\n",
    "**Compétences évaluées :**\n",
    "- Manipulation de tuples et listes\n",
    "- Dictionnaires et structures imbriquées\n",
    "- Algorithmes de filtrage et tri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Données initiales\n",
    "\n",
    "**Exécutez cette cellule avant de commencer.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pokedex (liste de tuples)\n",
    "# Chaque Pokemon : (nom, types, pv, attaque, defense, vitesse, evolution)\n",
    "# types est un tuple de 1 ou 2 types\n",
    "# evolution est None si pas d'evolution\n",
    "\n",
    "pokedex = [\n",
    "    (\"Bulbizarre\", (\"Plante\", \"Poison\"), 45, 49, 49, 45, \"Herbizarre\"),\n",
    "    (\"Herbizarre\", (\"Plante\", \"Poison\"), 60, 62, 63, 60, \"Florizarre\"),\n",
    "    (\"Florizarre\", (\"Plante\", \"Poison\"), 80, 82, 83, 80, None),\n",
    "    (\"Salameche\", (\"Feu\",), 39, 52, 43, 65, \"Reptincel\"),\n",
    "    (\"Reptincel\", (\"Feu\",), 58, 64, 58, 80, \"Dracaufeu\"),\n",
    "    (\"Dracaufeu\", (\"Feu\", \"Vol\"), 78, 84, 78, 100, None),\n",
    "    (\"Carapuce\", (\"Eau\",), 44, 48, 65, 43, \"Carabaffe\"),\n",
    "    (\"Carabaffe\", (\"Eau\",), 59, 63, 80, 58, \"Tortank\"),\n",
    "    (\"Tortank\", (\"Eau\",), 79, 83, 100, 78, None),\n",
    "    (\"Pikachu\", (\"Electrique\",), 35, 55, 40, 90, \"Raichu\"),\n",
    "    (\"Raichu\", (\"Electrique\",), 60, 90, 55, 110, None),\n",
    "    (\"Evoli\", (\"Normal\",), 55, 55, 50, 55, \"Multiple\"),\n",
    "    (\"Aquali\", (\"Eau\",), 130, 65, 60, 65, None),\n",
    "    (\"Voltali\", (\"Electrique\",), 65, 65, 60, 130, None),\n",
    "    (\"Pyroli\", (\"Feu\",), 65, 130, 60, 65, None),\n",
    "    (\"Mewtwo\", (\"Psy\",), 106, 110, 90, 130, None),\n",
    "    (\"Mew\", (\"Psy\",), 100, 100, 100, 100, None),\n",
    "    (\"Dracolosse\", (\"Dragon\", \"Vol\"), 91, 134, 95, 80, None),\n",
    "    (\"Leviator\", (\"Eau\", \"Vol\"), 95, 125, 79, 81, None),\n",
    "    (\"Lokhlass\", (\"Eau\", \"Glace\"), 130, 85, 80, 60, None)\n",
    "]\n",
    "\n",
    "# Table des faiblesses (type_attaquant -> liste des types faibles)\n",
    "faiblesses = {\n",
    "    \"Feu\": [\"Plante\", \"Glace\"],\n",
    "    \"Eau\": [\"Feu\", \"Sol\"],\n",
    "    \"Plante\": [\"Eau\", \"Sol\"],\n",
    "    \"Electrique\": [\"Eau\", \"Vol\"],\n",
    "    \"Glace\": [\"Dragon\", \"Vol\", \"Plante\"],\n",
    "    \"Psy\": [\"Poison\"],\n",
    "    \"Dragon\": [\"Dragon\"],\n",
    "    \"Vol\": [\"Plante\"]\n",
    "}\n",
    "\n",
    "# Equipe du joueur (liste de noms)\n",
    "mon_equipe = [\"Pikachu\", \"Dracaufeu\", \"Tortank\", \"Dracolosse\", \"Mewtwo\", \"Evoli\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 1 - Exploration du Pokédex (25 min)\n",
    "\n",
    "### 1.1 Affichage d'un Pokémon (4 pts)\n",
    "\n",
    "Écrivez une fonction `afficher_pokemon(pokemon)` qui affiche les infos d'un Pokémon.\n",
    "\n",
    "Exemple :\n",
    "```\n",
    "DRACAUFEU (Feu/Vol)\n",
    "PV: 78 | ATK: 84 | DEF: 78 | VIT: 100\n",
    "Evolution: Forme finale\n",
    "```\n",
    "\n",
    "*Rappel : pokemon[0] = nom, pokemon[1] = types, pokemon[2] = pv, pokemon[3] = attaque, pokemon[4] = defense, pokemon[5] = vitesse, pokemon[6] = evolution*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def afficher_pokemon(pokemon):\n",
    "    nom = pokemon[0]\n",
    "    types = pokemon[1]\n",
    "    pv = pokemon[2]\n",
    "    attaque = pokemon[3]\n",
    "    defense = pokemon[4]\n",
    "    vitesse = pokemon[5]\n",
    "    evolution = pokemon[6]\n",
    "    \n",
    "    # Afficher le nom et les types\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    # Afficher les stats\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    # Afficher l'evolution (\"Forme finale\" si None)\n",
    "    # Votre code ici\n",
    "    pass\n",
    "\n",
    "# Test\n",
    "afficher_pokemon(pokedex[5])  # Dracaufeu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Recherche par type (4 pts)\n",
    "\n",
    "Écrivez une fonction `pokemon_par_type(dex, type_recherche)` qui renvoie tous les Pokémon ayant ce type (principal ou secondaire), triés par PV décroissants.\n",
    "\n",
    "*Aide : utilisez `sorted(liste, key=lambda p: p[2], reverse=True)` pour trier par PV*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pokemon_par_type(dex, type_recherche):\n",
    "    resultats = []\n",
    "    \n",
    "    for pokemon in dex:\n",
    "        types = pokemon[1]\n",
    "        # Verifier si le type recherche est dans les types du pokemon\n",
    "        # Votre code ici\n",
    "        pass\n",
    "    \n",
    "    # Trier par PV (indice 2) decroissants\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    return resultats\n",
    "\n",
    "# Test\n",
    "print(\"Pokemon de type Eau :\")\n",
    "for p in pokemon_par_type(pokedex, \"Eau\"):\n",
    "    print(\" \", p[0], \"-\", p[2], \"PV\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Compter les types (4 pts)\n",
    "\n",
    "Écrivez une fonction `compter_types(dex)` qui renvoie un dictionnaire `{type: nombre}` comptant combien de Pokémon ont chaque type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compter_types(dex):\n",
    "    compteur = {}\n",
    "    \n",
    "    for pokemon in dex:\n",
    "        types = pokemon[1]\n",
    "        for t in types:\n",
    "            # Ajouter le type au compteur\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    return compteur\n",
    "\n",
    "# Test\n",
    "print(\"Nombre de Pokemon par type :\")\n",
    "types_compteur = compter_types(pokedex)\n",
    "for t, nb in types_compteur.items():\n",
    "    print(\" \", t, \":\", nb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 2 - Gestion d'équipe (35 min)\n",
    "\n",
    "### 2.1 Charger une équipe (5 pts)\n",
    "\n",
    "Écrivez une fonction `charger_equipe(noms, dex)` qui renvoie la liste des tuples Pokemon correspondant aux noms donnés.\n",
    "\n",
    "Si un nom n'existe pas dans le Pokédex, l'ignorer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def charger_equipe(noms, dex):\n",
    "    equipe = []\n",
    "    \n",
    "    for nom_recherche in noms:\n",
    "        # Chercher le pokemon dans le pokedex\n",
    "        for pokemon in dex:\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    return equipe\n",
    "\n",
    "# Test\n",
    "equipe = charger_equipe(mon_equipe, pokedex)\n",
    "print(\"Equipe chargee :\")\n",
    "for p in equipe:\n",
    "    print(\" \", p[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Force totale de l'équipe (5 pts)\n",
    "\n",
    "Écrivez une fonction `force_equipe(equipe)` qui calcule la force totale de l'équipe.\n",
    "\n",
    "Force d'un Pokémon = PV + Attaque + Défense + Vitesse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def force_equipe(equipe):\n",
    "    force_totale = 0\n",
    "    \n",
    "    for pokemon in equipe:\n",
    "        # Calculer la force du pokemon et l'ajouter au total\n",
    "        # Votre code ici\n",
    "        pass\n",
    "    \n",
    "    return force_totale\n",
    "\n",
    "# Test\n",
    "print(\"Force totale de l'equipe :\", force_equipe(equipe))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Pokémon le plus fort (5 pts)\n",
    "\n",
    "Écrivez une fonction `plus_fort(equipe)` qui renvoie le Pokémon ayant la meilleure attaque."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plus_fort(equipe):\n",
    "    if len(equipe) == 0:\n",
    "        return None\n",
    "    \n",
    "    meilleur = equipe[0]\n",
    "    meilleure_attaque = equipe[0][3]\n",
    "    \n",
    "    for pokemon in equipe:\n",
    "        # Comparer l'attaque avec la meilleure\n",
    "        # Votre code ici\n",
    "        pass\n",
    "    \n",
    "    return meilleur\n",
    "\n",
    "# Test\n",
    "fort = plus_fort(equipe)\n",
    "if fort:\n",
    "    print(\"Pokemon le plus fort :\", fort[0], \"avec\", fort[3], \"d'attaque\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Types couverts par l'équipe (6 pts)\n",
    "\n",
    "Écrivez une fonction `types_couverts(equipe)` qui renvoie la liste (sans doublons) de tous les types présents dans l'équipe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def types_couverts(equipe):\n",
    "    types_liste = []\n",
    "    \n",
    "    for pokemon in equipe:\n",
    "        types = pokemon[1]\n",
    "        for t in types:\n",
    "            # Ajouter le type s'il n'est pas deja dans la liste\n",
    "            # Votre code ici\n",
    "            pass\n",
    "    \n",
    "    return types_liste\n",
    "\n",
    "# Test\n",
    "print(\"Types couverts par l'equipe :\", types_couverts(equipe))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice 3 - Bonus (20 min)\n",
    "\n",
    "### 3.1 Chaîne d'évolution (5 pts)\n",
    "\n",
    "Écrivez une fonction `chaine_evolution(nom, dex)` qui renvoie la chaîne d'évolution complète d'un Pokémon.\n",
    "\n",
    "Exemple : `chaine_evolution(\"Bulbizarre\", pokedex)` → `[\"Bulbizarre\", \"Herbizarre\", \"Florizarre\"]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chaine_evolution(nom, dex):\n",
    "    chaine = [nom]\n",
    "    \n",
    "    # Chercher le pokemon actuel\n",
    "    pokemon_actuel = None\n",
    "    for p in dex:\n",
    "        if p[0] == nom:\n",
    "            pokemon_actuel = p\n",
    "            break\n",
    "    \n",
    "    if pokemon_actuel == None:\n",
    "        return chaine\n",
    "    \n",
    "    # Suivre les evolutions\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    return chaine\n",
    "\n",
    "# Tests\n",
    "print(chaine_evolution(\"Bulbizarre\", pokedex))\n",
    "print(chaine_evolution(\"Pikachu\", pokedex))\n",
    "print(chaine_evolution(\"Mewtwo\", pokedex))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Vérifier efficacité (5 pts)\n",
    "\n",
    "Écrivez une fonction `est_efficace(attaquant, defenseur, faiblesses)` qui renvoie `True` si l'attaquant a un type efficace contre le défenseur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def est_efficace(attaquant, defenseur, faiblesses):\n",
    "    types_attaquant = attaquant[1]\n",
    "    types_defenseur = defenseur[1]\n",
    "    \n",
    "    # Pour chaque type de l'attaquant, verifier s'il est efficace\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    return False\n",
    "\n",
    "# Tests\n",
    "pikachu = pokedex[9]\n",
    "tortank = pokedex[8]\n",
    "dracaufeu = pokedex[5]\n",
    "\n",
    "print(\"Pikachu efficace contre Tortank ?\", est_efficace(pikachu, tortank, faiblesses))\n",
    "print(\"Dracaufeu efficace contre Tortank ?\", est_efficace(dracaufeu, tortank, faiblesses))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Meilleur contre un adversaire (4 pts)\n",
    "\n",
    "Écrivez une fonction `meilleur_contre(adversaire, equipe, faiblesses)` qui renvoie le Pokémon de l'équipe le plus efficace contre l'adversaire.\n",
    "\n",
    "S'il n'y a pas de Pokémon efficace, renvoyer le plus fort en attaque."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def meilleur_contre(adversaire, equipe, faiblesses):\n",
    "    # D'abord chercher un pokemon efficace\n",
    "    # Votre code ici\n",
    "    pass\n",
    "    \n",
    "    # Sinon renvoyer le plus fort en attaque\n",
    "    return plus_fort(equipe)\n",
    "\n",
    "# Test\n",
    "leviator = pokedex[18]\n",
    "choix = meilleur_contre(leviator, equipe, faiblesses)\n",
    "if choix:\n",
    "    print(\"Meilleur choix contre Leviator :\", choix[0])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}