ISN Final

# "Petits Chevaux revisités" par Marin Cardo, Elliot Maisl et Hugo Quivrin (TS3) - 2020. Projet d'ISN.
import random
import time
import math


# ---------- Variables & configuration ----------

# Mode "développeur" (tester + rapidement: désactive les temps entre les messages et attribue des noms automatiques aux
# joueurs (1, 2, 3, 4))
MODE_DEV = True

# Textes des cases mystères
TEXTES_CASES_MYSTERES = ["vous revenez de 2 cases en arrière.", "vous avancez de 2 cases.", "vous pouvez rejouer."]

# Liste des mini-jeux
MINIJEUX = ["Quizz", "Dé"]

# Les tableaux sont formés de la façon suivante :
# QUESTIONS_QUIZZ_CATÉGORIE = [("question", "réponse"), ("question", "réponse"), ...]
QUESTIONS_QUIZZ_HISTOIRE = [
    ("Quel est le nom de la célèbre prison assiégée lors de la Révolution le 14 juillet 1789 ? (pas de majuscules)", "bastille"),
    ("Quelle est la date de signature de l'armistice suivantla Seconde Guerre Mondiale ? (jour en chiffre et mois en lettres)", "8 mai")]

QUESTIONS_QUIZZ_GEOGRAPHIE = [
    ("Quelle est la capitale du Canada ?", "ottawa"),
    ("Combien d'États comptent les États-Unis ?", "50"),
    ("Quel pays d'Asie possède sur son drapeau national un dragon blanc ?", "bhoutan")]

QUESTIONS_QUIZZ_SPORT = [
    ("Combien de Coupe du Monde de Football le Brésil a-t-il gagné ?", "5"),
    ("Quelle langue est, avec l'anglais, la langue officielle des Jeux Olympiques ?", "français"),
    ("Comment s'appelle le Grand Chelem se déroulant en Angleterre ?", "wimbledon"),
    ("Combien de joueurs  composent un roster (équipe complète) de football américain ?", "53")]

QUESTIONS_QUIZZ_SCIENCES = [
    ("Qui est  à l'origine de la théorie de la relativité générale ?", "einstein"),
    ("Sur la vibration de quel atome se basent les horloges atomiques ? (juste le nom)", "cesium"),
    ("A quel catégorie appartient une roche magmatique ayant refroidit lentement en profondeur ?", "plutonique"),
    ("Dans un cercle trigonométrique, le sens horaire correspond-t-il au sens positif ou négatif ?", "négatif")]

# Nombre total de cases
NOMBRE_CASES = 56
# Nombre de cases dans la colonne finale
NOMBRE_CASES_COLONNES = 6
# Liste des cases qui ont un minijeux dans la colonne finale
CASES_COLONNES_AVEC_JEU = [1, 4]
# Nombre total de joueurs
NOMBRE_JOUEURS = 4
# Nombre de cheval par joueur
NOMBRE_PIONS_PAR_JOUEUR = 2
# Liste de toutes les cases
cases = []
# Liste de tous les pions
joueurs = []

gagnant = None


# ---------- Fonctions ----------

# Fonction pour lancer le dé (renvoie un nombre entre 1 et 6 inclus)
def lancer_de():
    return random.randint(1, 6)


# Fonction pour vérifier que le texte donné est un nombre. (renvoie True ou False)
def est_nombre(valeur):
    # On test de vérifier si la valeur n'est pas un nombre (si c'est un texte)
    try:
        return not math.isnan(float(valeur))
    # Sauf que si c'est autre chose qu'un texte, il met une erreur, donc on récupère l'erreur et plutôt que de planter
    # on renvoit "faux" (la valeur n'est pas un nombre)
    except ValueError:
        return False


# Fonction pour demander un utilisateur un nombre.
def demande_nombre(question):
    nombre = input(question)
    while not est_nombre(nombre):  # Tant que le nombre n'est pas valide, on redemande
        nombre = input("Entrez un nombre valide (1, 2...) :")
    return int(nombre)


# Codage des mini-jeux sous forme de fonctions
def quizz(pion):
    print("Un quizz est lancé ! Répondez aux questions posées sans majuscules ou ponctuation.")
    if not MODE_DEV: time.sleep(2)

    categorie = input("Choisissez un thème parmis ceux-la : 'Histoire' , 'Géographie', 'Sciences', 'Sport'. (pas de majuscules)")
    while categorie not in ['histoire', 'géographie', 'sport', 'sciences']:
        categorie = input("'Histoire' , 'Géographie', 'Sciences' ou 'Sport' ? (pas de majuscules)")

    # Liste des joueurs ayant répondu correctement à la question (on doit les stocker pour leur avertir à la fin du
    # quizz s'ils avaient bon. On ne peut pas leur dire directement sinon les joueurs suivant sauront la réponse)
    correct = []

    if categorie == "histoire":
        print("Vous avez choisi Histoire.")
        num_question = random.randint(0, len(QUESTIONS_QUIZZ_HISTOIRE) - 1)
        question = QUESTIONS_QUIZZ_HISTOIRE[num_question][0]  # Question au hazard
        print(question)
        if not MODE_DEV: time.sleep(5)

        # Pour chaque joueur
        for i in range(NOMBRE_JOUEURS):
            # On le stock dans la variable adversaire
            adversaire = joueurs[i]
            reponse = input("Joueur " + adversaire.nom + ", quelle est votre réponse ?")
            print("D'accord !")

            if reponse == QUESTIONS_QUIZZ_HISTOIRE[num_question][1]:
                # S'il a bon, on l'ajoute à la liste "correct"
                correct.append(adversaire)

    elif categorie == "géographie":
        print("Vous avez choisi Géographie.")
        num_question = random.randint(0, len(QUESTIONS_QUIZZ_GEOGRAPHIE) - 1)
        question = QUESTIONS_QUIZZ_GEOGRAPHIE[num_question][0]
        print(question)
        if not MODE_DEV: time.sleep(5)

        for i in range(NOMBRE_JOUEURS):
            adversaire = joueurs[i]
            reponse = input("Joueur " + adversaire.nom + ", quelle est votre réponse ?")
            print("D'accord !")

            if reponse == QUESTIONS_QUIZZ_GEOGRAPHIE[num_question][1]:
                correct.append(adversaire)

    elif categorie == "sport":
        print("Vous avez choisi Sport.")
        num_question = random.randint(0, len(QUESTIONS_QUIZZ_SPORT) - 1)
        question = QUESTIONS_QUIZZ_SPORT[num_question][0]
        print(question)
        if not MODE_DEV: time.sleep(5)

        for i in range(NOMBRE_JOUEURS):
            adversaire = joueurs[i]
            reponse = input("Joueur " + adversaire.nom + ", quelle est votre réponse ?")
            print("D'accord !")

            if reponse == QUESTIONS_QUIZZ_SPORT[num_question][1]:
                correct.append(adversaire)

    elif categorie == "sciences":
        print("Vous avez choisi Sciences. ")
        num_question = random.randint(0, len(QUESTIONS_QUIZZ_SCIENCES) - 1)
        question = QUESTIONS_QUIZZ_SCIENCES[num_question][0]
        print(question)
        if not MODE_DEV: time.sleep(5)

        for i in range(NOMBRE_JOUEURS):
            adversaire = joueurs[i]
            reponse = input("Joueur " + adversaire.nom + ", quelle est votre réponse ?")
            print("D'accord !")

            if reponse == QUESTIONS_QUIZZ_SCIENCES[num_question][1]:
                correct.append(adversaire)

    # Pour tous les joueurs qui ont bon
    for adversaire in correct:
        print("")
        print("Bien joué,", adversaire.nom + ", vous avez répondu correctement !")
        # S'il a bien répondu
        # Est le joueur dont c'est le tour de jouer, on bouge le pion qu'il utilise
        # Sinon on lui demande de choisir le pion qu'il veut bouger
        pion_adversaire = pion if adversaire.nom == joueur.nom else adversaire.choisir_pion()
        pion_adversaire.move(1)


def jeu_de(pion):
    # On choisit un adversaire, qui n'est pas le joueur
    adversaire = joueurs[random.randint(0, NOMBRE_JOUEURS - 1)]
    while adversaire.nom == joueur.nom:
        adversaire = joueurs[random.randint(0, NOMBRE_JOUEURS - 1)]

    print("Un Jeu du Dé est lancé !", joueur.nom, "affronte", adversaire.nom)
    if not MODE_DEV: time.sleep(2)
    print("Le Jeu du Dé commence, devinez le chiffre sur lequel le dé va tomber ! Le gagnant avancera d'une case.")
    if not MODE_DEV: time.sleep(2)

    chiffre_mystere = lancer_de()

    # Les joueurs proposent leurs chiffres
    chiffre_propose1 = demande_nombre(joueur.nom + ", proposez votre prédiction")
    chiffre_propose2 = demande_nombre(adversaire.nom + ", proposez votre prédiction")

    if not MODE_DEV: time.sleep(1)
    print("Et le chiffre est...")
    if not MODE_DEV: time.sleep(2)
    print(chiffre_mystere, "!!!")
    if not MODE_DEV: time.sleep(1)

    # Si le chiffre est différent chez les deux joueurs
    if chiffre_propose1 != chiffre_mystere and chiffre_propose2 != chiffre_mystere:
        print("Vous avez tous les deux perdus, vous n'avez pas prédis le bon chiffre, c'était une chance sur six aussi !")
    # Si le chiffre a été prédis par le joueur 1 mais pas par le joueur 2
    elif chiffre_propose1 == chiffre_mystere and chiffre_propose2 != chiffre_mystere:
        print(joueur.nom, "a réussi à deviner le chiffre du dé !", adversaire.nom, "tu as perdu !")
        pion.move(1)
    elif chiffre_propose2 == chiffre_mystere and chiffre_propose1 != chiffre_mystere:
        print(adversaire.nom, "a réussi à deviner le chiffre du dé !", joueur.nom, "tu as perdu !")
        if not MODE_DEV: time.sleep(1)
        pion_adversaire = adversaire.choisir_pion()
        pion_adversaire.move(1)

    # Si le chiffre est identique chez les deux joueurs
    else:
        print("Vous avez gagné tous les deux ! Vous avez prédis le bon chiffre, quels chanceux vous êtes !")
        pion.move(1)
        pion_adversaire = adversaire.choisir_pion()
        pion_adversaire.move(1)


# Fonction pour gérer un tour. Elle renvoit True ou False selon si l'on doit rejouer ou pas.
def gerer_tour(joueur):
    doit_rejouer = False

    print("Vous avez", joueur.nombre_pions_en_jeu, "pions en jeu.")
    # On définit la variable "pion" au pion que le joueur utilise pour ce tour.
    pion = joueur.choisir_pion()

    # On affiche des informations relatives au pion choisit
    if pion.dans_colonne:
        print("Vous utilisez le pion", pion.numero, "(case", pion.id_case, "|",
              NOMBRE_CASES_COLONNES - pion.cases_colonne, "cases restantes avant le milieu)")
    else:
        print("Vous utilisez le pion", pion.numero, "(case", pion.id_case, "|",
              pion.cases_restantes, "cases restantes avant la colonne)")

    if not MODE_DEV: time.sleep(1)
    print("Lancez le dé puis déplacez-vous d'autant de cases que le chiffre indiqué")
    if not MODE_DEV: time.sleep(2)
    mouvement = lancer_de()
    print("Vous faites un", mouvement, "!")

    # Le joueur est dans la colonne
    if pion.dans_colonne:
        # Il faut faire avec le dé le même nombre que le numéro de notre case. Si on est devant la colonne (pas
        # encore dedans) il faut faire 1.
        expecte = pion.cases_colonne

        if mouvement == expecte:
            pion.move(1)
        else:
            print("Vous n'avez pas avancé car il fallait faire un", expecte, "et vous avez fait un", mouvement, ".")
            if not MODE_DEV: time.sleep(1)
            print("Vous êtes toujours sur la", pion.cases_colonne, "e case de la colonne finale.")

        # Si le joueur se situe dans une case de la colonne finale comportant un jeu, le programme se déclenche
        if pion.cases_colonne in CASES_COLONNES_AVEC_JEU:
            if not MODE_DEV: time.sleep(1)
            print("Vous allez participer à un mini-jeu !")
            mini_jeu = MINIJEUX[random.randint(0, len(MINIJEUX) - 1)]
            if mini_jeu == "Quizz":
                quizz(pion)
            elif mini_jeu == "Dé":
                jeu_de(pion)

    # Le joueur n'est pas dans la colonne
    else:
        # On bouge le pion (les messages et le check de si on dépasse la case finale sont aussi dans cette méthode)
        pion.move(mouvement)

        # Si la case sur laquelle on est tombée est mystère (on vérifie d'abord qu'on ne soit pas dans la colonne.
        # On peut y être car on a bougé avant, donc on a pu y rentré. Si on ne vérifie pas cela, l'id de la case ou on
        # est (pion.id_case) va être plus grand que le nombre de cases et on va avoir une erreur "index out of range").
        if not pion.dans_colonne and cases[pion.id_case].mystere:
            if not MODE_DEV: time.sleep(1)
            text = cases[pion.id_case].text
            print("Vous êtes atteris sur une case mystère,", text)
            if not MODE_DEV: time.sleep(2)

            if text == "vous revenez de 2 cases en arrière.":
                pion.move(-2)

            elif text == "vous avancez de 2 cases.":
                pion.move(2)

            elif text == "vous pouvez rejouer.":
                print("Vous rejouerez juste après avoir terminé ce tour.")
                doit_rejouer = True

        # Si le joueur n'a pas encore utilisé son bonus de relance
        if not joueur.a_relance:
            if not MODE_DEV: time.sleep(1)
            reponse = input(
                "Voulez-vous tenter de relancer les dés (possible qu'une fois dans la partie) ? (oui/non) :")

            if reponse == "oui":
                joueur.a_relance = True
                devine = demande_nombre("Prévoyez la valeur du dé entre 1 et 6 :")

                relance = lancer_de()
                if devine == relance:
                    pion.move(relance)
                else:
                    print(relance, "! Dommage vous avez raté votre seul chance de relancer les dés...")

    if doit_rejouer:
        print("")
        print("Joueur", joueur.nom, "vous rejouez !")
        gerer_tour(joueur)


# ---------- Classes ----------

# Classe d'une case
class Case:
    def __init__(self, id_case, mystere):
        self.mystere = mystere  # Est ce que la case est une case mystère
        self.id_case = id_case  # ID de la case
        if mystere:
            self.text = TEXTES_CASES_MYSTERES[random.randint(0, len(TEXTES_CASES_MYSTERES) - 1)]


# Class d'un joueur
class Joueur:
    def __init__(self, nom):
        self.nom = nom  # Nom du joueur
        self.a_relance = False  # Si le joueur a déjà utilisé son bonus pour relancer le dé
        self.a_gagne = False  # Si le joueur a gagné
        self.pions = []  # Liste des pions du joueur (tous les pions sont des instances de la classe Pion)
        self.score = 0  # Score du joueur (calculé seulement à la fin de la partie, par la méthode calcul_score())
        for i in range(NOMBRE_PIONS_PAR_JOUEUR):
            self.pions.append(Pion(i + 1, self))  # On remplit la liste des pions par des pions
        # Nombre de pions qui peuvent encore jouer (qui n'ont pas gagnés). Utilisé pour savoir si on doit lui demander
        # de choisir un pion a bouger en début de tour ou pas. (pas besoin de demander s'il ne lui reste qu'un pion)
        self.nombre_pions_en_jeu = NOMBRE_PIONS_PAR_JOUEUR

    def choisir_pion(self):
        # S'il a plusieurs pions en jeu, on lui demande avec le quel il veut jouer
        if self.nombre_pions_en_jeu > 1:
            for pion_joueur in self.pions:
                if not pion_joueur.a_fini:
                    if pion_joueur.dans_colonne:
                        print("  - Pion", pion_joueur.numero, ": case", pion_joueur.id_case, "|",
                              NOMBRE_CASES_COLONNES - pion_joueur.cases_colonne, "cases restantes avant le milieu.")
                    else:
                        print("  - Pion", pion_joueur.numero, ": case", pion_joueur.id_case, "|",
                              pion_joueur.cases_restantes, "cases restantes avant la colonne.")

            index_pion = demande_nombre("Choisissez avec quel pion jouer (1, 2, ...) :")
            index_pion -= 1
            # Tant que le numéro du pion n'est pas valide
            while index_pion > self.nombre_pions_en_jeu - 1 or index_pion < 0:
                index_pion = demande_nombre("Choisissez avec quel pion jouer (1, 2, ...) :")
                index_pion -= 1

            pion = joueur.pions[index_pion]

        # Sinon il joue avec le seul pion qui n'a pas fini
        else:
            for pion_joueur in joueur.pions:
                if not pion_joueur.a_fini:
                    pion = pion_joueur

        # On renvoit le pion déterminé
        return pion

    def calcul_score(self):
        # On calcul le score d'un joueur (la facon de calculer le score est totalement arbitraire)
        pion_fini = NOMBRE_PIONS_PAR_JOUEUR - self.nombre_pions_en_jeu  # Nb de pions qui ont finis
        self.score += pion_fini * 100  # 100 points par pions ayant finis

        for pion_joueur in self.pions:
            if not pion_joueur.a_fini:
                # On ajoute a cela le numéro de la case de tous les pions n'ayant pas finit
                self.score += pion_joueur.id_case
                if pion_joueur.dans_colonne:
                    # Si le pion est dans la colonne finale, on multiplie la case de la col. par 2 et on ajoute au score
                    self.score += pion_joueur.cases_colonne * 2


# Classe d'un pion
class Pion:
    def __init__(self, numero, joueur):
        self.numero = numero  # Numéro du pion
        self.id_case = 0  # ID de la case ou est le pion
        self.joueur = joueur  # Joueur a qui ce pion appartient

        self.cases_restantes = NOMBRE_CASES  # Nombre de cases avant la colonne
        self.cases_colonne = 0  # Numéro de la case de la colonne
        self.dans_colonne = False  # Si le pion est dans la colonne

        self.a_fini = False  # Si le pion a finit

    def move(self, de):
        global gagnant  # On permet à cette méthode d'accéder et de modifier la variable "gagnant"

        self.id_case += de

        # Si on est déjà dans la colonne finale
        if self.dans_colonne:
            self.cases_colonne += de
            if self.cases_colonne == NOMBRE_CASES_COLONNES:  # Si on a finit
                print("Bravo, vous êtes arrivé au milieu ! Le pion", self.numero, "a terminé !")
                joueur.nombre_pions_en_jeu -= 1
                self.a_fini = True
                if joueur.nombre_pions_en_jeu == 0:
                    joueur.a_gagne = True
                    gagnant = self.joueur

        # Si on est pas encore à la colonne
        else:
            self.cases_restantes -= de

            # Si on a dépassé la colonne (on doit reculer du nombre de cases en trop)
            if self.cases_restantes < 0:
                recul = int(math.fabs(self.id_case - NOMBRE_CASES))
                self.id_case -= recul * 2
                self.cases_restantes += recul * 2
                print("Eh pas si vite ! Vous avez fait un", de,
                      "et avez dépassé le début de la colonne. Vous avez donc avancé de", de - recul, "et reculé de",
                      recul, ". Vous êtes maintenant sur la case", self.id_case, ".")
                if not MODE_DEV: time.sleep(2)

            # Sinon on avance normalement
            else:
                print("Vous vous êtes déplacé de", de, "case(s). Vous êtes maintenant sur la case", self.id_case, ".")
                if self.cases_restantes == 0:
                    self.id_case += 1
                    self.cases_colonne = 1
                    self.dans_colonne = True
                    print("Vous venez d'entrer dans votre colonne finale ! Bravo.")
                if not MODE_DEV: time.sleep(2)


# Création de toutes les cases
for i in range(NOMBRE_CASES):
    # 1 case sur 14 en partant de la 7ème est une case mystère
    if (i + 7) % 14 == 0:
        cases.append(Case(i, True))
    else:
        cases.append(Case(i, False))

noms_pris = []  # Liste contenant les noms pris (pour éviter que 2 joueurs choisissent le même nom)
# Création de tous les pions
for i in range(NOMBRE_JOUEURS):
    if MODE_DEV:
        nom = str(i + 1)
    else:
        nom = input("Nom du joueur " + str(i + 1) + " : ")
        while nom in noms_pris:
            nom = input("Ce nom est déjà pris. Choisis un nouveau nom : ")
        noms_pris.append(nom)
    joueurs.append(Joueur(nom))


# ---------- Code principal (tours) ----------

# On commence par afficher les règles
afficher_regles = input("Voulez-vous voir les règles ? (oui/non)")
while afficher_regles not in ['oui', 'non']:
    afficher_regles = input("Voulez-vous voir les règles ? (oui/non)")

if afficher_regles == 'oui':
    print("Le but est d'ammener tous ses pions au milieu.")
    if not MODE_DEV: time.sleep(2)
    print("Chaque joueur a", NOMBRE_PIONS_PAR_JOUEUR, "pions.")
    if not MODE_DEV: time.sleep(2)
    print("Le plateau est constitué de", NOMBRE_CASES, "cases, menant à une colonne finale.")
    if not MODE_DEV: time.sleep(3)
    print("Cette colonne finale est constituée de", NOMBRE_CASES_COLONNES, "cases.")
    if not MODE_DEV: time.sleep(3)
    print("Pour avancer, vous devez tirer le dé. Vous pouvez tomber sur des cases mystères avec des bonus ou des malus.")
    if not MODE_DEV: time.sleep(5)
    print("Si vous dépassez l'entrée de la colonne, vous reculerez du nombre de cases en trop.")
    if not MODE_DEV: time.sleep(3)
    print("Une fois entré dans la colonne finale, il faudra faire avec le dé le nombre de la case sur laquelle vous êtes.")
    if not MODE_DEV: time.sleep(5)
    print("Par exemple, si vous êtes sur la 4ème case de la colonne, vous devez faire '4' avec le dé pour aller à la case suivante.")
    if not MODE_DEV: time.sleep(5)
    print("Certaines cases de la colonne vous mènerons à un petit jeu : un quizz ou tout le monde participe ou un jeu" +
          "de dé ou un adversaire est tiré au sort.")
    if not MODE_DEV: time.sleep(6)
    print("Bonne chance !")
    if not MODE_DEV: time.sleep(2)

print("C'est parti !")
if not MODE_DEV: time.sleep(2)

# Numéro du tour
tour = 1

# On boucle tant que personne n'a gagné. Une boucle = un tour complet des joueurs
while not gagnant:
    print("")
    print("")
    print("")
    print("")
    print("Le tour", tour, "commence !")

    # Pour chaque tour, on fait les 4 joueurs
    for i in range(NOMBRE_JOUEURS):
        # On définit la variable "joueur" au joueur a qui c'est le tour
        joueur = joueurs[i]

        print("")
        print("")
        print("")
        print("Joueur", joueur.nom, "c'est votre tour !")

        gerer_tour(joueur)

        # S'il y a un gagnant, on quitte le "for" qui boucle les 4 joueurs
        if gagnant:
            break

    # Quand les 4 joueurs ont joués, on passe au tour suivant
    tour += 1

print("")
print("")
print("")
print("")
print("La partie est terminée ! Tous les pions du joueur", gagnant.nom, "sont arrivés ! Il remporte la partie !")
if not MODE_DEV: time.sleep(1)
print("")
print("Voici le classement :")


# On calcul le score de tous les joueurs
for i in range(NOMBRE_JOUEURS):
    joueurs[i].calcul_score()

# On créé un classement (on trie la liste "joueurs" selon la clé "score", dans l'ordre décroissant)
classement = sorted(joueurs, key=lambda j: j.score, reverse=True)

for i in range(len(classement)):
    print(i + 1, ":", classement[i].nom, "(" + str(classement[i].nombre_pions_en_jeu), "pion(s) en jeu) [" + str(classement[i].score) + "]")

exit(0)  # On quitte le programme proprement, sans générer d'erreur