# --------------------------------------------------------------------------------------
# EXEMPLE D'UNE CLASSE C_JOUEUR DEFINISSANT UNE IA JOUANT BETEMENT SES CARTES AU HASARD
# --------------------------------------------------------------------------------------

from kblibpub import *

try:
    from random import choice
except:
    from urandom import choice

SILENT_MODE = True


# SOME SIMPLE FUNCTIONS TO PRINT WITH COLOR USING ANSI CODES (MAYBE NOT TRANSVERSE TO ALL PLATEFORMS)
class Colors:
    """ ANSI color codes """
    BLACK = "\033[0;30m"
    RED = "\033[0;31m"
    GREEN = "\033[0;32m"
    ORANGE = "\033[0;33m"
    BLUE = "\033[0;34m"
    PURPLE = "\033[0;35m"
    CYAN = "\033[0;36m"
    LIGHT_GRAY = "\033[0;37m"
    DARK_GRAY = "\033[1;30m"
    LIGHT_RED = "\033[1;31m"
    LIGHT_GREEN = "\033[1;32m"
    YELLOW = "\033[1;33m"
    LIGHT_BLUE = "\033[1;34m"
    LIGHT_PURPLE = "\033[1;35m"
    LIGHT_CYAN = "\033[1;36m"
    LIGHT_WHITE = "\033[1;37m"
    BOLD = "\033[1m"
    FAINT = "\033[2m"
    ITALIC = "\033[3m"
    UNDERLINE = "\033[4m"
    BLINK = "\033[5m"
    NEGATIVE = "\033[7m"
    CROSSED = "\033[9m"
    END = "\033[0m"

def print_red(skk):
    if not SILENT_MODE:
        print(Colors.RED + "{}".format(skk) + Colors.END)
def print_orange(skk):
    if not SILENT_MODE:
        print(Colors.ORANGE + "{}".format(skk) + Colors.END)
def print_yellow(skk):
    if not SILENT_MODE:
        print(Colors.YELLOW + "{}".format(skk) + Colors.END)
def print_green(skk):
    if not SILENT_MODE:
        print(Colors.GREEN + "{}".format(skk) + Colors.END)
def print_blue(skk):
    if not SILENT_MODE:
        print(Colors.BLUE + "{}".format(skk) + Colors.END)
def print_cyan(skk):
    if not SILENT_MODE:
        print(Colors.CYAN + "{}".format(skk) + Colors.END)
def print_purple(skk):
    if not SILENT_MODE:
        print(Colors.PURPLE + "{}".format(skk) + Colors.END)

def strlst(l):
    s = ""
    for v in l: s += " " + str(v)
    return s


class c_joueur:

    def __init__(self, num_joueur, nbr_joueurs, points_objectif):
        self.num_joueur = num_joueur  # mon numero de joueur
        self.nbr_joueurs = nbr_joueurs  # nombre total de joueurs
        # informations de jeu collectees sur l'ensemble des joueurs
        self.infos_joueurs = [
            i == num_joueur and c_infos_jeu_et_main(i, nbr_joueurs, points_objectif) or c_infos_jeu(i, nbr_joueurs,
                                                                                                    points_objectif)
            for i in range(nbr_joueurs)
        ]
        # mes informations de jeu
        self.infos_joueur = self.infos_joueurs[num_joueur]

        # nom de l'IA
        self.nom_joueur = "SLYnapse 10.0"
        # version de l'IA
        self.ver_joueur = "020"
        # nom de groupe (optionnel, pour les participants decidant de rejoindre un groupe)
        self.nom_groupe = "br.AI.n all.IA.ge"
        # signature du groupe (a demander et recuperer aupres du chef de groupe)
        self.sig_groupe = "One BrAIn to Rule Them All."
        # cri de victoire de l'IA
        self.msg_joueur = (
            "Je suis SLYnapse-10.0 ... Moi en mode Truel, je maçonne :D")


        self.last_turn_attack = False
        self.last_turn_limit = False
        # Pour match 1 vs 1, donne le numéro du joueur adverse
        self.cible1vs1 = 1-self.infos_joueur.num_joueur


    def a_attaque_en_main(self):
        # cette fonction indique si nous avons en main de quoi lancer une attaque
        # sans distinction d'attaque
        for cte in self.infos_joueur.main:
            if est_carte_attaque(cte):
                return True
        return False

    def a_crevaison_en_main(self):
        # cette fonction indique si on a une carte crevaison en main
        for cte in self.infos_joueur.main:
            if cte == I_CREVAISON:
                return True
        return False

    def a_panne_essence_en_main(self):
        # cette fonction indique si on a une carte panne d'essence en main
        for cte in self.infos_joueur.main:
            if cte == I_PANNE_ESSENCE:
                return True
        return False

    def a_accident_en_main(self):
        # cette fonction indique si on a une carte accident en main
        for cte in self.infos_joueur.main:
            if cte == I_ACCIDENT:
                return True
        return False

    def a_feu_rouge_en_main(self):
        # cette fonction indique si on a une carte feu rouge en main
        for cte in self.infos_joueur.main:
            if cte == I_FEU_ROUGE:
                return True
        return False

    def a_limitation_vitesse_en_main(self):
        # cette fonction indique si on a une carte limitation de vitesse en main
        for cte in self.infos_joueur.main:
            if cte == I_LIMITATION:
                return True
        return False

    def peut_avoir_crevaison(self, num_joueur):
        # fonction qui indique si le joueur #num_joueur peut crever
        if self.infos_joueurs[num_joueur].vehicule_roulant():
            if not I_VEHICULE_INCREVABLE in self.infos_joueurs[num_joueur].bottes:
                return True
        return False

    def peut_avoir_panne_essence(self, num_joueur):
        # fonction qui indique si le joueur #num_joueur peut crever
        if self.infos_joueurs[num_joueur].vehicule_roulant():
            if not I_CAMION_CITERNE in self.infos_joueurs[num_joueur].bottes:
                return True
        return False

    def peut_avoir_accident(self, num_joueur):
        # fonction qui indique si le joueur #num_joueur peut crever
        if self.infos_joueurs[num_joueur].vehicule_roulant():
            if not I_AS_VOLANT in self.infos_joueurs[num_joueur].bottes:
                return True
        return False

    def peut_avoir_feu_rouge(self, num_joueur):
        # fonction qui indique si le joueur #num_joueur peut crever
        if self.infos_joueurs[num_joueur].vehicule_roulant():
            if not I_VEHICULE_PRIORITAIRE in self.infos_joueurs[num_joueur].bottes:
                return True
        return False

    def peut_avoir_limitation_vitesse(self, num_joueur):
        # fonction qui indique si le joueur #num_joueur peut crever
        if self.infos_joueurs[num_joueur].vehicule_roulant():
            if not I_VEHICULE_PRIORITAIRE in self.infos_joueurs[num_joueur].bottes:
                return True
        return False

    def a_double_en_main(self, carte):
        # cette fonction retourne True si on a la carte en double
        nombre_item = 0
        for cte in self.infos_joueur.main:
            if cte == carte:
                nombre_item += 1
        if nombre_item >= 2:
            return True
        return False

    def recupere_attaque(self):
        return self.infos_joueur.pile_bataille[-1]

    def recupere_limitation(self):
        return self.infos_joueur.pile_vitesse[-1]

    def suis_je_limite_en_vitesse(self):
        # indique si on est actuellement sous le coup d'une limitation de vitesse
        if len(self.infos_joueur.pile_vitesse):
            crte = self.infos_joueur.pile_vitesse[-1]
            if est_carte_attaque(crte):
                # Si on était pas limité la dernière fois et que désormais on l'est, cela signifie que la limite date du dernier
                # tour (on pourra se servir de cette donnée pour placer un coup fourré et gagner quelques points)
                if not self.last_turn_limit:
                    self.last_turn_limit = True
                return True
            else:
                # Sinon on est pas soumis à une attaque et on met last_turn_attack à False
                self.last_turn_limit = False
                return False

        self.last_turn_limit = False
        return False


    def suis_je_sujet_a_une_attaque(self):
        # indique si on est actuellement sous le coup d'une attaque
        if len(self.infos_joueur.pile_bataille):
            crte = self.infos_joueur.pile_bataille[-1]
            if est_carte_attaque(crte):
                # Si on était pas attaqué la dernière fois et que désormais on l'est, cela signifie que l'attaque date du dernier
                # tour (on pourra se servir de cette donnée pour placer un coup fourré et gagner quelques points)
                if not self.last_turn_attack:
                    self.last_turn_attack = True
                return True
            else:
                # Sinon on est pas soumis à une attaque et on met last_turn_attack à False
                self.last_turn_attack = False
                return False

        self.last_turn_attack = False
        return False

    def decide_meilleure_attaque(self):
        # cette fonction a pour but de regarder qui parmis les opposants est le plus dangereux
        # et doit donc devenir la cible privilégiée pour une attaque.

        # PHASE 0 : on regarde si on a au moins une possibilité d'attaquer

        # si on a pas de carte d'attaque, on revoie None
        if not self.a_attaque_en_main():
            print_red("RIEN POUR ATTAQUER")
            return None

        print_cyan("ON A DE QUOI ATTAQUER, VOYONS VOIR QUI EST LA MEILLEURE CIBLE")

        # PHASE 1 : on recherche qui est le plus près de la victoire et on en fait la cible privilégiée

        tuples = []
        nb_total_cibles = 0

        for i in range(self.nbr_joueurs):
            # on balaye l'ensemble des joueurs mais on évite de se cibler
            # pour multiplayer, on évite d'attaquer un partenaire de sa propre équipe en regardant si il fait partie du
            # meme groupe

            # TODO : activer cette condition quand les groupes seront activés
            # if not i == self.num_joueur and not self.nom_groupe == self.infos_joueurs[i].nom_groupe:
            if not i == self.num_joueur:
                tuples.append((self.infos_joueurs[i].bornes, i))
                nb_total_cibles += 1
            else:
                print_red("Je vais pas me tirer une balle dans le pied quand même !!!")

        tuples.sort(key=lambda x: x[0], reverse=True)
        best_target = tuples[0][1]
        kms_target = tuples[0][0]
        print_cyan("Voici mon inventaire de la situation" + str(tuples))
        print_cyan(
            "MEILLEURE CIBLE : Joueur #" + str(best_target) + " avec ses " + str(kms_target) + " Km au compteur !!!")

        # PHASE 2 : la cible première est identifiée, on regarde si elle est sensible a une attaque dont on a possession
        # PHASE 3 : si la cible premiere est immunisée alors on passe à la suivante dans le ranking
        for j in range(nb_total_cibles):
            cible = tuples[j][1]
            kms = tuples[j][0]
            print_purple("CIBLE : Joueur #" + str(cible) + " avec ses " + str(kms) + " Km au compteur !!!")
            if self.a_panne_essence_en_main() and self.peut_avoir_panne_essence(cible):
                coup = c_coup(self.num_joueur, I_PANNE_ESSENCE, cible)
                print_cyan("Il est sensible aux PANNES D'ESSENCE, donc voici une petite fuite !!!")
                return coup
            elif self.a_crevaison_en_main() and self.peut_avoir_crevaison(cible):
                coup = c_coup(self.num_joueur, I_CREVAISON, cible)
                print_cyan("Il est sensible aux CREVAISONS, donc voilà une pointe !!!")
                return coup
            elif self.a_accident_en_main() and self.peut_avoir_accident(cible):
                coup = c_coup(self.num_joueur, I_ACCIDENT, cible)
                print_cyan("Il est sensible aux ACCIDENT, donc voilà une flaque d'huile !!!")
                return coup
            elif self.a_feu_rouge_en_main() and self.peut_avoir_feu_rouge(cible):
                coup = c_coup(self.num_joueur, I_FEU_ROUGE, cible)
                print_cyan("Il est sensible aux FEU ROUGE, donc voici pour te stopper !!!")
                return coup
            elif self.a_limitation_vitesse_en_main() and self.peut_avoir_limitation_vitesse(cible):
                coup = c_coup(self.num_joueur, I_LIMITATION, cible)
                print_cyan("Tu roules comme un JACKY, voici un radar pour toi copain ;-) !!!")
                return coup
            else:
                print_cyan("CE JOUEUR EST INATTAQUABLE EN L'ETAT")
                print_cyan("ON TENTE LE PROCHAIN SUR LA LISTE")

        # PHASE 4 : on a tout essayé, mais on ne peut vraiment pas attaquer
        print_purple("AUCUNE ATTAQUE POSSIBLE : DOMMAGE ")
        return None

    def decide_meilleure_carte_a_jeter(self):
        coup = None

        # priorité 1 : si on a une carte 200 et on a dejà joué 2 cartes 200
        if I_200_BORNES in self.infos_joueur.main and self.infos_joueur.bornes200 == 2:
            coup = c_coup(self.num_joueur, I_200_BORNES, SABOT)
            return coup

        # priorité 2 : si on a une protection par une botte et une parade associée alors on jette la parade
        if I_FEU_VERT in self.infos_joueur.main and I_VEHICULE_PRIORITAIRE in self.infos_joueur.bottes:
            coup = c_coup(self.num_joueur, I_FEU_VERT, SABOT)
            return coup
        if I_FIN_LIMITATION in self.infos_joueur.main and I_VEHICULE_PRIORITAIRE in self.infos_joueur.bottes:
            coup = c_coup(self.num_joueur, I_FIN_LIMITATION, SABOT)
            return coup
        if I_ROUE_SECOURS in self.infos_joueur.main and I_VEHICULE_INCREVABLE in self.infos_joueur.bottes:
            coup = c_coup(self.num_joueur, I_ROUE_SECOURS, SABOT)
            return coup
        if I_POMPE_ESSENCE in self.infos_joueur.main and I_CAMION_CITERNE in self.infos_joueur.bottes:
            coup = c_coup(self.num_joueur, I_POMPE_ESSENCE, SABOT)
            return coup
        if I_REPARATIONS in self.infos_joueur.main and I_AS_VOLANT in self.infos_joueur.bottes:
            coup = c_coup(self.num_joueur, I_REPARATIONS, SABOT)
            return coup

        # priorité 3 : on check si on a une carte en double dans les trucs pas très utiles
        if self.a_double_en_main(I_FEU_VERT):
            coup = c_coup(self.num_joueur, I_FEU_VERT, SABOT)
            return coup

        if self.a_double_en_main(I_FIN_LIMITATION):
            coup = c_coup(self.num_joueur, I_FIN_LIMITATION, SABOT)
            return coup

        # TODO : à compléter cette liste.

        return coup

    def test_si_botte_possible(self, attaque_en_cours):
        for c in self.infos_joueur.main:
            # on check si on peut faire un coup fourré pour les diverses attaques possibles
            if attaque_en_cours == I_LIMITATION and c == I_VEHICULE_PRIORITAIRE:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_green("Coup fourré - limitation terminée")
                return coup
            elif attaque_en_cours == I_FEU_ROUGE and c == I_VEHICULE_PRIORITAIRE:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_green("Coup fourré - feu rouge terminé")
                return coup
            elif attaque_en_cours == I_CREVAISON and c == I_VEHICULE_INCREVABLE:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_green("Coup fourré - crevaison terminée")
                return coup
            elif attaque_en_cours == I_ACCIDENT and c == I_AS_VOLANT:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_green("Coup fourré - accident terminé")
                return coup
            elif attaque_en_cours == I_PANNE_ESSENCE and c == I_CAMION_CITERNE:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_green("Coup fourré - panne essence terminée")
                return coup
        return None

    def test_si_parade_possible(self, attaque_en_cours):
        for c in self.infos_joueur.main:
            # on check si on peut lancer la parade à l'attaque en cours pour chacune des diverses attaques possibles
            if attaque_en_cours == I_LIMITATION and c == I_FIN_LIMITATION:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_cyan("Parade - limitation terminée")
                return coup
            elif attaque_en_cours == I_FEU_ROUGE and c == I_FEU_VERT:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_cyan("Parade - feu rouge teminé")
                return coup
            elif attaque_en_cours == I_CREVAISON and c == I_ROUE_SECOURS:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_cyan("Parade - crevaison terminée")
                return coup
            elif attaque_en_cours == I_ACCIDENT and c == I_REPARATIONS:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_cyan("Parade - accident terminé")
                return coup
            elif attaque_en_cours == I_PANNE_ESSENCE and c == I_POMPE_ESSENCE:
                coup = c_coup(self.num_joueur, c, self.num_joueur)
                print_cyan("Parade - panne essence terminée")
                return coup
        return None

    def retourne_vitesse_maxie_autorisee(self):
        vitesse_limitee = False
        max_vitesse_limitation = 200

        # on vérifie si on est pas sous le coup d'une limitation de vitesse dont on a pas su se défaire
        if self.suis_je_limite_en_vitesse():
            vitesse_limitee = True
            max_vitesse_limitation = 50

        # on vérifie si on a pas déjà joué 2 cartes 200km/h et si oui on limite à 100km/h au maximum
        if self.infos_joueur.bornes200 >= 2:
            max_vitesse_limitation = 100

        kilometrage_actuel = self.infos_joueur.bornes
        cible_kilometre = self.infos_joueur.bornes_arrivee
        max_vitesse_cible = cible_kilometre - kilometrage_actuel

        vitesse_autorisee_max = min(max_vitesse_limitation, max_vitesse_cible)

        return vitesse_autorisee_max

    def affiche_infos_situation(self):
        st = strlst([CODES_CARTES[carte] for carte in self.infos_joueur.main])
        print_yellow("Voici ma main AVANT tirage dans la pioche : " + st)
        if self.infos_joueur.vehicule_roulant(): print_green("Je suis en train de rouler.")
        else: print_blue("Actuellement je ne roule pas !!")
        return

    def retourne_mon_classement(self):
        tuples = []
        for i in range(self.nbr_joueurs):
            tuples.append((self.infos_joueurs[i].bornes, self.infos_joueurs[i].num_joueur))

        tuples.sort(key=lambda x: x[0], reverse=True)

        for i in range(self.nbr_joueurs):
            if tuples[i][1] == self.infos_joueur.num_joueur:
                return i

    def retourne_km_dispo_en_main(self):
        # cette fonction calcule la somme des kilometres que le joueur a en main
        total = 0
        for cte in self.infos_joueur.main:
            if est_carte_bornes(cte):
                total += valeur_carte_bornes(cte)
        return total

    def retourne_joueur_le_plus_dangereux(self):
        tuples = []
        for i in range(self.nbr_joueurs):
            tuples.append((self.infos_joueurs[i].bornes, self.infos_joueurs[i].num_joueur))

        tuples.sort(key=lambda x: x[0], reverse=True)
        return tuples[0][1]

    def retourne_km_du_joueur_le_plus_dangereux(self):
        tuples = []
        for i in range(self.nbr_joueurs):
            tuples.append((self.infos_joueurs[i].bornes, self.infos_joueurs[i].num_joueur))

        tuples.sort(key=lambda x: x[0], reverse=True)
        return tuples[0][1]

    def est_ce_que_adversaire_est_arrete(self, adversaire):
        return self.infos_joueurs[adversaire].vehicule_roulant()

    def attaque_adversaire(self):
        coup = None
        if self.a_panne_essence_en_main() and self.peut_avoir_panne_essence(self.cible1vs1):
            coup = c_coup(self.num_joueur, I_PANNE_ESSENCE, self.cible1vs1)
            print_cyan("Il est sensible aux PANNES D'ESSENCE, donc voici une petite fuite !!!")
            return coup
        elif self.a_crevaison_en_main() and self.peut_avoir_crevaison(self.cible1vs1):
            coup = c_coup(self.num_joueur, I_CREVAISON, self.cible1vs1)
            print_cyan("Il est sensible aux CREVAISONS, donc voilà une pointe !!!")
            return coup
        elif self.a_accident_en_main() and self.peut_avoir_accident(self.cible1vs1):
            coup = c_coup(self.num_joueur, I_ACCIDENT, self.cible1vs1)
            print_cyan("Il est sensible aux ACCIDENT, donc voilà une flaque d'huile !!!")
            return coup
        elif self.a_feu_rouge_en_main() and self.peut_avoir_feu_rouge(self.cible1vs1):
            coup = c_coup(self.num_joueur, I_FEU_ROUGE, self.cible1vs1)
            print_cyan("Il est sensible aux FEU ROUGE, donc voici pour te stopper !!!")
            return coup
        elif self.a_limitation_vitesse_en_main() and self.peut_avoir_limitation_vitesse(self.cible1vs1):
            coup = c_coup(self.num_joueur, I_LIMITATION, self.cible1vs1)
            print_cyan("Tu roules comme un JACKY, voici un radar pour toi copain ;-) !!!")
            return coup
        return coup

    def joue_meilleur_coup(self):
        vitesse_maxie = self.retourne_vitesse_maxie_autorisee()

        coup = None

        if self.infos_joueur.bornes200<2 and vitesse_maxie >= 200 and I_200_BORNES in self.infos_joueur.main:
            coup = c_coup(self.num_joueur, I_200_BORNES, self.num_joueur)
            print_green("+200KM pour moi !!!")
            return coup
        if self.infos_joueur.bornes100<2 and vitesse_maxie >= 100 and I_100_BORNES in self.infos_joueur.main:
            coup = c_coup(self.num_joueur, I_100_BORNES, self.num_joueur)
            print_green("+100KM pour moi !!!")
            return coup
        if vitesse_maxie >= 75 and I_75_BORNES in self.infos_joueur.main:
            coup = c_coup(self.num_joueur, I_75_BORNES, self.num_joueur)
            print_green("+75KM pour moi !!!")
            return coup
        if vitesse_maxie >= 50 and I_50_BORNES in self.infos_joueur.main:
            coup = c_coup(self.num_joueur, I_50_BORNES, self.num_joueur)
            print_green("+50KM pour moi !!!")
            return coup
        if vitesse_maxie >= 25 and I_25_BORNES in self.infos_joueur.main:
            coup = c_coup(self.num_joueur, I_25_BORNES, self.num_joueur)
            print_green("+25KM pour moi !!!")
            return coup

        for carte in cartes_bottes():
            if carte in self.infos_joueur.main:
                coup = c_coup(self.num_joueur, carte, self.num_joueur)
                return coup

        return coup

    # --------------------------------------------------
    # DEBUT DES FONCTIONS NECESSITANT D'ETRE AMELIOREES
    # -------------------------------------------------
    def decide_coup(self):
        carte = None
        origine, destination = self.num_joueur, self.num_joueur

        # TODO : il faut vérifier la condition pour le coup fourré, si l'attaque n'a pas été
        # TODO : posée lors du dernier tour, alors le coup fourré ne fonctionnera pas.

        # teste si un COUP FOURRE est possible avant de tirer une carte dans la pioche
        # Phase I : (pile de bataille)
        if self.suis_je_sujet_a_une_attaque():
            # On vérifie que l'attaque date bien du dernier tour pour essayer de poser un coup fourré
            if self.last_turn_attack:
                crte = self.recupere_attaque()
                coup = self.test_si_botte_possible(crte)
                if coup is not None:
                    print_green("Le COUP FOURRE est possible contre BATAILLE !!! GO")
                    return coup

        # Phase II : (pile de limitation de vitesse)
        if self.suis_je_limite_en_vitesse():
            crte = self.recupere_limitation()
            coup = self.test_si_botte_possible(crte)
            if coup is not None:
                print_green("Le COUP FOURRE est possible contre LIMITATION !!! GO")
                return coup


        # Comme les coups direct ne sont pas possibles, on regarde si on doit tirer une carte dans la pioche pour
        # complèter la main
        if len(self.infos_joueur.main) < self.taille_main:
            # si on a moins de <taille_main> cartes en main, alors on peut tirer une carte du <SABOT>
            # et la rajouter a sa main
            origine = SABOT
            st = strlst([CODES_CARTES[carte] for carte in self.infos_joueur.main])
            # affiche la main avant pioche en jaune
            print_orange("Voici ma main AVANT tirage dans la pioche : " + st)
            coup = c_coup(origine, carte, destination)
            return coup

        # Fonction d'affichage
        self.affiche_infos_situation()

        # On attaque l'adversaire si il avance, attitude très aggressive de l'IA
        if self.est_ce_que_adversaire_est_arrete(self.cible1vs1):
            coup = self.attaque_adversaire()
            if coup is not None:
                print_green("Attaque préventive")
                return coup


        # TODO : on test une IA nettement plus aggressive
        if not self.retourne_mon_classement() == 0 or self.suis_je_sujet_a_une_attaque():
            coup = self.decide_meilleure_attaque()
            if coup is not None:
                print_green("VOICI UNE ATTAQUE !!!")
                return coup


        if not self.suis_je_sujet_a_une_attaque(): print_green("Pas de carte de bataille à traiter : OK ")
        else: print_red("Il faut traiter cette carte de bataille")

        # on traite en premier lieu l'attaque qui est l'embetement principal
        if self.suis_je_sujet_a_une_attaque():
            # PHASE I : on regarde si on a la parade
            crte = self.recupere_attaque()
            coup = self.test_si_parade_possible(crte)
            if coup is not None:
                print_green("La PARADE est possible !!! GO")
                return coup
            # PHASE II : on regarde si on a la botte
            # (mais dommage de perdre la possibilité de gagner un extra via un coup fourré)
            coup = self.test_si_botte_possible(crte)
            if coup is not None:
                print_purple("On peut se défendre mais on perd l'avantage coup FOURRE !!! GO")
                return coup
            # PHASE III : on a rien pour se défaire de cette attaque avec notre jeu actuel
            print_red("Pas possible de se débarrasser de cette attaque pour le moment")


        if not self.suis_je_limite_en_vitesse(): print_blue("Pas de carte de limitation à traiter : OK ")
        else: print_orange("Il faut traiter cette carte de limitation")

        # on traite ensuite la limitation de vitesse
        if self.suis_je_limite_en_vitesse():
            # TODO : regarder si la limitation de vitesse est vraiment un probleme
            # TODO : par exemple si on est limite a 50km/h et qu'on est à 50km ou moins de la cible de fin de partie

            # PHASE I : on regarde si on a la parade
            crte = self.recupere_limitation()
            coup = self.test_si_parade_possible(crte)
            if coup is not None:
                print_green("La PARADE est possible !!! GO")
                return coup
            # PHASE II : on regarde si on a la botte
            coup = self.test_si_botte_possible(crte)
            # (mais dommage de perdre la possibilité de gagner un extra via un coup fourré)
            if coup is not None:
                print_purple("On peut se défendre mais on perd l'avantage coup FOURRE !!! GO")
                return coup
            # PHASE III : on a rien pour se défaire de cette attaque avec notre jeu actuel
            print_red("Pas possible de se débarrasser de cette limitation pour le moment")


        # si a ce stade on a rien pu faire pour se débarraser de l'attaque en cours, on cherche aussi à attaquer
        # les adversaires
        if self.suis_je_sujet_a_une_attaque():
            coup = self.decide_meilleure_attaque()
            if coup is not None:
                print_green("VOICI UNE ATTAQUE !!!")
                return coup
            print_red("GROS PROBLEME : IL FAUT PIOCHER POUR ESPERER TROUVER UNE PARADE OU ATTAQUER !!! ")


        # si a ce stade on a rien pu faire pour se débarraser de l'attaque en cours,
        # on tente la pioche qui est la seule option possible
        if self.suis_je_sujet_a_une_attaque():
            print_red("IL RESTE SEULEMENT LA PIOCHE")
            coup = self.decide_meilleure_carte_a_jeter()
            if coup is not None:
                print_blue("C'EST UN CREVE COEUR DE TE JETER !!!")
                return coup


        if not self.infos_joueur.vehicule_roulant() and I_FEU_VERT in self.infos_joueur.main:
            print_green("Mais j'ai un feu vert pour démarrer, donc GO !!!")
            coup = c_coup(self.num_joueur, I_FEU_VERT, self.num_joueur)
            return coup

        if not self.infos_joueur.vehicule_roulant() and not I_FEU_VERT in self.infos_joueur.main:
            print_red("Je ne sais pas démarrer car pas de feu vert dans ma main")
            print_red("Peut-être que je peux emmerder les autres ?!?")
            coup = self.decide_meilleure_carte_a_jeter()
            if coup is not None:
                print_blue("C'EST UN CREVE COEUR DE TE JETER !!!")
                return coup

        if self.infos_joueur.vehicule_roulant():
            coup = self.joue_meilleur_coup()
            if coup is not None:
                return coup


        # choisit la carte au hasard en tout dernier ressort
        # TODO : virer tous ces cas pour ne plus laisser aucune place au hasard
        carte = choice(self.infos_joueur.main)

        # si c'est une carte d'attaque, choisit au hasard le joueur/IA qui est attaque (utile pour les parties a plus de 2 joueurs)
        if est_carte_attaque(carte):
            autres_joueurs = [i for i in range(self.nbr_joueurs)]
            autres_joueurs.remove(self.num_joueur)
            destination = choice(autres_joueurs)

        coup = c_coup(origine, carte, destination)

        # exemple d'une des nombreuses ameliorations possibles selon les regles du 1000 Bornes
        # SI
        # - je ne peux pas rouler
        # - ET je ne suis pas sous le coup d'une attaque
        # - ET j'ai une carte <I_FEU_VERT> en main
        # ALORS je joue la carte <I_FEU_VERT> dans mon jeu

        if not self.infos_joueur.vehicule_roulant() \
                and not est_carte_attaque(self.infos_joueur.carte_bataille()) \
                and I_FEU_VERT in self.infos_joueur.main:
            coup = c_coup(self.infos_joueur.num_joueur, I_FEU_VERT, self.infos_joueur.num_joueur)

        return coup

    def pari_allonge(self, bornes_arrivee):
        # Par défaut on continue
        t = False
                
        return t

    # --------------------------------------------------
    # FIN DES FONCTIONS NECESSITANT D'ETRE AMELIOREES
    # --------------------------------------------------

    def id_str(self):
        return self.infos_joueur.id_str() + " {:s} v{:s}".format(self.nom_joueur, self.ver_joueur)

    def nouvelle_manche(self, nbr_cartes, taille_main, bornes_arrivee):
        self.taille_main = taille_main
        for infos_joueur in self.infos_joueurs:
            infos_joueur.nouvelle_manche(nbr_cartes, taille_main, bornes_arrivee)

    def fin_manche(self, bornes_joueurs, len_pioche):
        for infos_joueur in self.infos_joueurs:
            infos_joueur.fin_manche(bornes_joueurs, len_pioche)

    def allonge(self, num_joueur, bornes_arrivee):
        for infos_joueur in self.infos_joueurs:
            infos_joueur.allonge(num_joueur, bornes_arrivee)

    def traite_coup(self, coup):
        for i in range(self.nbr_joueurs): self.infos_joueurs[i].traite_coup(coup)

    def rejoint_groupe(self, num_joueur, nom_groupe):
        self.infos_joueurs[num_joueur].nom_groupe = nom_groupe