# pour creer ta propre IA compatible avec le jeu du 1000 Bornes
# tu dois utiliser, completer ou deriver la classe <c_joueur> selon les specifications decrites ci-apres
# ton travail consiste essentiellement a y completer la fonction <decide_coup()> de la facon la plus intelligente possible
# tu es libre de modifier et completer comme bon te semble ce fichier sous ces specifications
# a la seule condition que tes ajouts fassent partie de la classe <c_joueur>
# (pas de variables globales, car elles pourraient perturber le comportement des IA concurrentes)

# LES IAs
# 2 scripts d'IA sont incluse par defaut :
# - "ia_random.py" : une IA basique d'exemple, jouant ses coups totalement au hasard
# - "ia_clavier.py" : une fausse IA, destinee a etre pilotee au clavier

# LANCER UNE PARTIE
# Le script principal a lancer est "kb.py".
# Si la plateforme le permet, il accepte en parametre :
# - les noms de scripts d'IA a faire s'affronter, au moins 2
# - une graine aleatoire optionnelle pour reproduire une partie bien precise
# Exemple : > python ia_clavier ia_random ia_random 42
# Lance une partie avec la graine aleatoire 42 et 3 joueurs :
# - 1 joueur humain au clavier
# - 2 joueurs utilisant l'IA definie dans 'ia_random.py"
# Sans parametre, les differents nombres de joueurs seront demandes.
# Ne pas hesiter dans ce cas a editer "kb.py" pour pouvoir faire appel a d'autres IAs.

# LES CARTES
# Les cartes du 1000 Bornes sont definies dans le script "kblibpub.py" et peuvent etre de differents types :
# - cartes d'attaque (I_CREVAISON, I_PANNE_ESSENCE, I_ACCIDENT, I_FEU_ROUGE, I_LIMITATION)
# - cartes de parade (I_ROUE_SECOURS, I_POMPE_ESSENCE, I_REPARATIONS, I_FEU_VERT, I_FIN_LIMITATION)
# - cartes de bottes (I_VEHICULE_INCREVABLE, I_CAMION_CITERNE, I_AS_VOLANT, I_VEHICULE_PRIORITAIRE)
# - cartes de bornes (I_25_BORNES, I_50_BORNES, I_75_BORNES, I_100_BORNES, I_200_BORNES)

# Quelques fonctions utiles :
# - <est_carte_attaque(carte)> : indique si <carte> est une carte d'attaque
# - <est_carte_parade(carte)> : indique si <carte> est une carte de parade
# - <est_carte_bottes(carte)> : indique si <carte> est une carte de bottes
# - <est_carte_bornes(carte)> : indique si <carte> est une carte de bornes

# LES PARAMETRES
# - Au 1000 Bornes, chaque joueur peut accueillir un maximum de 7 cartes dans sa main.
# - Le but d'une manche est de parcourir exactement 700 km, ou 1000 km en cas d'allonge.
# - Une partie (succession de manches) se termine lorsqu'un des joueurs depasse 5000 points. Nous prendrons ici 9000 points.

# LES ZONES
# Au jeu du 1000 Bornes interviennent differentes zones de jeu :
# * le <SABOT> avec :
#   - la pile de PIOCHE dont on tire les cartes que l'on rajoute a sa main
#   - la pile de DEFAUSSE ou l'on defausse les cartes de sa main
# * le jeu de chaque joueur, avec :
#   - la pile de vitesse ou l'on joue les cartes de limitation et fin de limitation
#   - la pile de bataille ou l'on joue toutes les cartes d'attaque et de parade
#   - la zone des bottes ou l'on joue les cartes de bottes
#   - la main de cartes tirees, invisible des autres joueurs

# COUPS ET CLASSE C_COUP
# les coups sont decrits par la classe <c_coup> deja definie dans "kblibpub.py"
# a chaque coup, une carte passe d'une zone d'origine a une zone de destination
# tout coup peut ainsi etre decrit par le triplet (origine, carte, destination)
# les differents types de coups :
# - si <origine> == <SABOT> : le joueur numero <destination> a tire la carte <carte>
# - si <destination> == <SABOT> : le joueur numero <origine> a defausse la carte <carte>
# - si <origine> == <destination> : le joueur numero <origine> a joue la carte <carte> dans son jeu
# - si <origine> != <destination> : le joueur numero <origine> a attaque le joueur numero <destination> avec <carte>

# ETATS DE JEU ET CLASSE C_INFOS_JEU(_ET_MAIN)
# l'etat du jeu de chaque joueur est decrit par la classe <c_infos_joueur> deja definie dans "kblibpub.py"
# librement utilisable, elle te permet de mettre a jour et acceder a toutes les informations utiles sur chaque joueur/IA

# quelques variables :
# - <num_joueur> : numero du joueur/IA concerne
# - <points> : points accumules par le joueur/IA depuis le debut de la partie
# - <num_joueurs_autres> : numeros des autres joueurs/IA
# - <bornes> : indique le nombre de km parcourus depuis le debut de la manche
# - <bornes100> : indique si le joueur/IA a joue une carte de 100 km au cours de la manche
# - <bornes200> : nombre de cartes de 200 km jouees par le joueur/IA au cours de la manche
# - <bottes> : liste des cartes de bottes jouees par le joueur/IA
# - <main> : liste des cartes en main du joueur/IA (uniquement definie si l'on joue le joueur/IA en question)
# - <coups_fourres_autorises> : liste des coups fourres pouvant etre joues au tout debut du tour en cours
# - <joueur_allonge> : si allonge, numero du joueur/IA l'ayant demandee, ou sinon <None>
# - <bornes_arrivee> : nombre exact de km a parcourir pour gagner la manche

# quelques fonctions :
# - <carte_bataille()> : carte en haut de la pile de bataille du joueur/IA
# - <carte_vitesse()> : carte en haut de la pile de vitesse du joueur/IA
# - <vehicule_roulant()> : indique si le joueur/IA est en capacite de rouler
# - <coup_invalide(coup)> : indique si <coup> est invalide du point de vue du joueur/IA
# - <pari_allonge(bornes_arrivee)> : appelee suite a une demande d'allonge par un joueur/IA, pour indiquer la nouvelle arrivee
# - <allonge()> : appelee lorsque le joueur/IA atteint l'arrivee pour la 1ere fois de la manche,
#     indique alors en retour si le joueur/IA souhaite repousser la ligne d'arrivee pour plus de poins
#     possibilite 1 fois par manche, de repousser la lignee d'arrivee de 700 km a 1000 km

# JOUEURS/IA ET CLASSE C_JOUEUR
# chaque joueur/IA est associe a une classe <c_joueur> ou compatible, a definitir dans son script de participation
# il est par exemple possible de partir du script d'exemple "ia_random.py" qui definit une IA aleatoire basique

# plusieurs variables y sont presentes :
# - <nom_joueur> : le nom du joueur/IA (contenu libre)
# - <ver_joueur> : la version du joueur/IA (contenu libre)
# - <msg_joueur> : message secret qui sera affiche en cas de victoire du joueur/IA (contenu libre)
# - <nbr_joueurs> : le nombre de joueurs/IA jouant la partie
# - <num_joueur> : le numero du joueur/IA dans la partie en cours
# - <infos_joueur> : classe <c_infos_jeu_et_main> decrivant l'etat du jeu et de la main du joueur/IA
# - <infos_joueurs> : liste de classes <c_infos_jeu> decrivant l'etat du jeu de l'ensemble des joueurs/IA
# - <taille_main> : nombre maximal de cartes en main

# lorsque c'est le tour du joueur/IA, sont appelees successivement 2 fonctions essentielles :
# - <decide_coup()> pour demander l'action souhaitee par le joueur/IA
# - <traite_coup(coup)> pour informer l'ensemble des joueurs/IA de l'action effectuee
# <traite_coup(coup)> est deja codee pour mettre a jour et te rendre accessible
# l'ensemble des informations dont tu peux avoir besoin sur les differents joueurs/IA
# c'est <decide_coup()> que tu vas devoir travailler pour rendre ton IA plus intelligente

# * fonction decide_coup() :
#   c'est cette fonction que tu vas avoir besoin de completer 
#   fonction appelee a chaque fois que c'est le tour du joueur/IA
#   doit retourner une instance de la classe <c_coup>, correspondant au coup souhaite
#   si le coup est invalide, pas de perte de points mais il sera considere comme un defaussement :
#   - de la carte concernee si bien presente en main
#   - ou sinon d'une carte aleatoire de la main

# * fonction traite_coup(coup) :
#   cette fonction est deja codee pour accumuler et rendre accessible l'ensemble des donnees dont tu peux avoir besoin
#   apres le traitement de chaque coup d'un des joueurs/IAs
#   tous les joueurs/IA sont informes du coup effectue par appel de <traite_coup(coup)>
#   l'appel est egalement effectue pour informer un joueur/IA de ses propres coups
#   (ce qui permet de savoir si un coup a ete considere comme invalide et de mettre a jour en consequence)
#   pour une carte tiree par un autre joueur/IA, la carte tiree ne sera pas precisee (coup.carte == None)
#   normalement, le joueur/IA ne peut joueur de carte qu'avec une main pleine, et donc apres avoir tire une carte
#   exception, si le joueur/IA a ete attaque juste avant son tour, et qu'il a deja la carte de bottes correspondante en main
#   possibilite de la jouer immediatement et ainsi realiser un coup fourre pour plus de points
#   les coups fourres ne sont plus possibles a partir du moment ou une carte a ete tiree lors du tour

# maintenant, a titre informatif voici les autres fonctions de la classe :

# * __init__(num_joueur, nbr_joueurs, points_objectif) :
#   cree le joueur/IA en lui indiquant :
#   - que l'on demarre une partie contre <nbr_joueurs> autres joueurs/IA
#   - qu'il a pour numero <num_joueur>
#   - que la partie prendre fin après que le score d'une IA depasse <points_objectif> points

# * nouvelle_manche(nbr_cartes, taille_main, bornes_arrivee) :
#   indique a l'IA que l'on demarre une nouvelle manche de la partie, avec :
#   - une pioche de <nbr_cartes> cartes
#   - au plus <taille_main> cartes en main pour chaque joueur
#   - et un objectif de <bornes_arrivee> kilometres

# * allonge(num_joueur, bornes_arrivee) :
#   indique que le joueur <num_joueur> a decide que
#   l'on repousse la ligne d'arrivee a <bornes_arrivee> kilometres