Carte POO

[MamanGvomi]

#!/usr/bin/python3 -i
import random

"""
la liste des caractères semi-graphiques correspondant aux différentes cartes
l'indice du caractère dans la liste correspond au codage des murs sur la carte
le caractère 'Ø' indique que l'indice ne correspond pas à une carte
"""
listeCartes=['╬','╦','╣','╗','╩','═','╝','Ø','╠','╔','║','Ø','╚','Ø','Ø','Ø']

class Carte(object):
    """constructeur de la carte"""
    def __init__(self, nord,est,sud,ouest,tresor=0,pions=[]):
        self.Carte={}
        self.Carte["Mur"]=set()
        if nord:
            self.Carte["Mur"].add("nord")
        if est:
            self.Carte["Mur"].add("est")
        if sud:
            self.Carte["Mur"].add("sud")
        if ouest:
            self.Carte["Mur"].add("ouest")
        self.Carte["Trésor"]=tresor
        self.Carte["pions"]=pions

    def estValide(self):
        """
        retourne un booléen indiquant si la carte est valide ou non c'est à dire qu'elle a un ou deux murs
        paramètre: c une carte
        """
        NbMur=len(self.Carte["Mur"])
        if NbMur==1:
            return True
        if NbMur==2:
            return True
        return False

    def murNord(self):
        """
        retourne un booléen indiquant si la carte possède un mur au nord
        paramètre: c une carte
        """
        return "nord" in self.Carte["Mur"]

    def murSud(self):
        """
        retourne un booléen indiquant si la carte possède un mur au sud
        paramètre: c une carte
        """
        return "sud" in self.Carte["Mur"]

    def murEst(self):
        """
        retourne un booléen indiquant si la carte possède un mur à l'est
        paramètre: c une carte
        """
        return "est" in self.Carte["Mur"]

    def murOuest(self):
        """
        retourne un booléen indiquant si la carte possède un mur à l'ouest
        paramètre: c une carte
        """
        return "ouest" in self.Carte["Mur"]

    def getListePions(self):
        """
        retourne la liste des pions se trouvant sur la carte
        paramètre: c une carte
        """
        return self.Carte["pions"]

    def setListePions(self,listePions):
        """
        place la liste des pions passées en paramètre sur la carte
        paramètres: c: est une carte
                    listePions: la liste des pions à poser
        Cette fonction ne retourne rien mais modifie la carte
        """
        self.Carte["pions"]=listePions

    def getNbPions(self):
        """
        retourne le nombre de pions se trouvant sur la carte
        paramètre: c une carte
        """
        return len(self.Carte["pions"])

    def possedePion(self,pion):
        """
        retourne un booléen indiquant si la carte possède le pion passé en paramètre
        paramètre: c une carte
        """
        return pion in self.Carte["pions"]

    def getTresor(self):
        """
        retourne la valeur du trésor qui se trouve sur la carte (0 si pas de trésor)
        paramètre: c une carte
        """
        return self.Carte["Trésor"]

    def prendreTresor(self):
        """
        enlève le trésor qui se trouve sur la carte et retourne la valeur de ce trésor
        paramètre: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        AncienTrésor=self.Carte["Trésor"]
        self.Carte["Trésor"]=0
        return AncienTrésor

    def mettreTresor(self,tresor):
        """
        met le trésor passé en paramètre sur la carte et retourne la valeur de l'ancien trésor
        paramètres: c une carte
                    tresor un entier positif
        Cette fonction modifie la carte mais ne retourne rien
        """
        AncienTrésor=self.Carte["Trésor"]
        self.Carte["Trésor"]=tresor
        return AncienTrésor

    def prendrePion(self, pion):
        """
        enlève le pion passé en paramètre de la carte. Si le pion n'y était pas ne fait rien
        paramètres: c une carte
                    pion un entier compris entre 1 et 4
        Cette fonction modifie la carte mais ne retourne rien
        """
        if pion in self.Carte["pions"]:
            self.Carte["pions"].remove(pion)

    def poserPion(self, pion):
        """
        pose le pion passé en paramètre sur la carte. Si le pion y était déjà ne fait rien
        paramètres: c une carte
                    pion un entier compris entre 1 et 4
        Cette fonction modifie la carte mais ne retourne rien
        """
        if pion not in self.Carte["pions"]:
            self.Carte["pions"].append(pion)

    def tournerHoraire(self):
        """
        fait tourner la carte dans le sens horaire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NvxMur=set()
        if "nord" in self.Carte["Mur"]:
            NvxMur.add("est")
        if "est" in self.Carte["Mur"]:
            NvxMur.add("sud")
        if "sud" in self.Carte["Mur"]:
            NvxMur.add("ouest")
        if "ouest" in self.Carte["Mur"]:
            NvxMur.add("nord")
        self.Carte["Mur"]=NvxMur

    def tournerAntiHoraire(self):
        """
        fait tourner la carte dans le sens anti-horaire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NvxMur=set()
        if "nord" in self.Carte["Mur"]:
            NvxMur.add("ouest")
        if "est" in self.Carte["Mur"]:
            NvxMur.add("nord")
        if "sud" in self.Carte["Mur"]:
            NvxMur.add("est")
        if "ouest" in self.Carte["Mur"]:
            NvxMur.add("sud")
        self.Carte["Mur"]=NvxMur

    def tourneAleatoire(self):
        """
        faire tourner la carte d'un nombre de tours aléatoire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NbTours=random.randint(1,10)
        for i in range(NbTours):
            sens=random.randint(0,1)
            if sens==0:
                tournerAntiHoraire(self)
            else:
                tournerHoraire(self)

    def coderMurs(self):
        """
        code les murs sous la forme d'un entier dont le codage binaire
        est de la forme bNbEbSbO où bN, bE, bS et bO valent
           soit 0 s'il n'y a pas de mur dans dans la direction correspondante
           soit 1 s'il y a un mur dans la direction correspondante
        bN est le chiffre des unité, BE des dizaine, etc...
        le code obtenu permet d'obtenir l'indice du caractère semi-graphique
        correspondant à la carte dans la liste listeCartes au début de ce fichier
        paramètre c une carte
        retourne un entier indice du caractère semi-graphique de la carte
        """
        indice=0
        if "nord" in self.Carte["Mur"]:
            indice+=1
        if "est" in self.Carte["Mur"]:
            indice+=2
        if "sud" in self.Carte["Mur"]:
            indice+=4
        if "ouest" in self.Carte["Mur"]:
            indice+=8
        return indice

    def decoderMurs(self,code):
        """
        positionne les murs d'une carte en fonction du code décrit précédemment
        paramètres c une carte
                   code un entier codant les murs d'une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        indice=[]
        Mur=set()
        codeBin=list(bin(code))
        del codeBin[0]
        del codeBin[0]
        for i in range(1,len(codeBin)+1):
            if codeBin[-i]=="1":
                indice.append(i)
        print(indice)
        if 1 in indice:
            Mur.add("nord")
        if 2 in indice:
            Mur.add("est")
        if 3 in indice:
            Mur.add("sud")
        if 4 in indice:
            Mur.add("ouest")
        self.Carte["Mur"]=Mur

carte1
    def toChar(self):
        """
        fournit le caractère semi graphique correspondant à la carte (voir la variable listeCartes au début de ce script)
        paramètres c une carte
        """
        indiceSemiGraph=coderMurs(self)
        return listeCartes[indiceSemiGraph]

    def passageNord(self,carte2):
        """
        suppose que la carte2 est placée au nord de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par le nord
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "nord" not in self.Carte["Mur"] and "sud" not in carte2.Carte["Mur"]

    def passageSud(self,carte2):
        """
        suppose que la carte2 est placée au sud de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par le sud
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "sud" not in self.Carte["Mur"] and "nord" not in carte2.Carte["Mur"]

    def passageOuest(self,carte2):
        """
        suppose que la carte2 est placée à l'ouest de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par l'ouest
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "ouest" not in self.Carte["Mur"] and "est" not in carte2.Carte["Mur"]

    def passageEst(self,carte2):
        """
        suppose que la carte2 est placée à l'est de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par l'est
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "est" not in self.Carte["Mur"] and "ouest" not in carte2.Carte["Mur"]

[Bulky42]

import random

"""
la liste des caractères semi-graphiques correspondant aux différentes cartes
l'indice du caractère dans la liste correspond au codage des murs sur la carte
le caractère 'Ø' indique que l'indice ne correspond pas à une carte
"""
listeCartes=['╬','╦','╣','╗','╩','═','╝','Ø','╠','╔','║','Ø','╚','Ø','Ø','Ø']

class Carte(object):
    """constructeur de la carte"""
    def __init__(self, nord,est,sud,ouest,tresor=0,pions=[]):
        self.mur=set()
        if nord:
            self.mur.add("nord")
        if est:
            self.mur.add("est")
        if sud:
            self.mur.add("sud")
        if ouest:
            self.mur.add("ouest")
        self.tresor=tresor
        self.pions=pions

    def estValide(self):
        """
        retourne un booléen indiquant si la carte est valide ou non c'est à dire qu'elle a un ou deux murs
        paramètre: c une carte
        """
        NbMur=len(self.mur)
        if NbMur==1:
            return True
        if NbMur==2:
            return True
        return False

    def murNord(self):
        """
        retourne un booléen indiquant si la carte possède un mur au nord
        paramètre: c une carte
        """
        return "nord" in self.mur

    def murSud(self):
        """
        retourne un booléen indiquant si la carte possède un mur au sud
        paramètre: c une carte
        """
        return "sud" in self.mur

    def murEst(self):
        """
        retourne un booléen indiquant si la carte possède un mur à l'est
        paramètre: c une carte
        """
        return "est" in self.mur

    def murOuest(self):
        """
        retourne un booléen indiquant si la carte possède un mur à l'ouest
        paramètre: c une carte
        """
        return "ouest" in self.mur

    def getListePions(self):
        """
        retourne la liste des pions se trouvant sur la carte
        paramètre: c une carte
        """
        return self.pions

    def setListePions(self,listePions):
        """
        place la liste des pions passées en paramètre sur la carte
        paramètres: c: est une carte
                    listePions: la liste des pions à poser
        Cette fonction ne retourne rien mais modifie la carte
        """
        self.pions=listePions

    def getNbPions(self):
        """
        retourne le nombre de pions se trouvant sur la carte
        paramètre: c une carte
        """
        return len(self.pions)

    def possedePion(self,pion):
        """
        retourne un booléen indiquant si la carte possède le pion passé en paramètre
        paramètre: c une carte
        """
        return pion in self.pions

    def getTresor(self):
        """
        retourne la valeur du trésor qui se trouve sur la carte (0 si pas de trésor)
        paramètre: c une carte
        """
        return self.tresor

    def prendreTresor(self):
        """
        enlève le trésor qui se trouve sur la carte et retourne la valeur de ce trésor
        paramètre: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        AncienTrésor=self.tresor
        self.tresor=0
        return AncienTrésor

    def mettreTresor(self,tresor):
        """
        met le trésor passé en paramètre sur la carte et retourne la valeur de l'ancien trésor
        paramètres: c une carte
                    tresor un entier positif
        Cette fonction modifie la carte mais ne retourne rien
        """
        AncienTrésor=self.tresor
        self.tresor=tresor
        return AncienTrésor

    def prendrePion(self, pion):
        """
        enlève le pion passé en paramètre de la carte. Si le pion n'y était pas ne fait rien
        paramètres: c une carte
                    pion un entier compris entre 1 et 4
        Cette fonction modifie la carte mais ne retourne rien
        """
        if pion in self.pions:
            self.pions.remove(pion)

    def poserPion(self, pion):
        """
        pose le pion passé en paramètre sur la carte. Si le pion y était déjà ne fait rien
        paramètres: c une carte
                    pion un entier compris entre 1 et 4
        Cette fonction modifie la carte mais ne retourne rien
        """
        if pion not in self.pions:
            self.pions.append(pion)

    def tournerHoraire(self):
        """
        fait tourner la carte dans le sens horaire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NvxMur=set()
        if "nord" in self.mur:
            NvxMur.add("est")
        if "est" in self.mur:
            NvxMur.add("sud")
        if "sud" in self.mur:
            NvxMur.add("ouest")
        if "ouest" in self.mur:
            NvxMur.add("nord")
        self.mur=NvxMur

    def tournerAntiHoraire(self):
        """
        fait tourner la carte dans le sens anti-horaire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NvxMur=set()
        if "nord" in self.mur:
            NvxMur.add("ouest")
        if "est" in self.mur:
            NvxMur.add("nord")
        if "sud" in self.mur:
            NvxMur.add("est")
        if "ouest" in self.mur:
            NvxMur.add("sud")
        self.mur=NvxMur

    def tourneAleatoire(self):
        """
        faire tourner la carte d'un nombre de tours aléatoire
        paramètres: c une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        NbTours=random.randint(1,10)
        for i in range(NbTours):
            sens=random.randint(0,1)
            if sens==0:
                tournerAntiHoraire(self)
            else:
                tournerHoraire(self)

    def coderMurs(self):
        """
        code les murs sous la forme d'un entier dont le codage binaire
        est de la forme bNbEbSbO où bN, bE, bS et bO valent
           soit 0 s'il n'y a pas de mur dans dans la direction correspondante
           soit 1 s'il y a un mur dans la direction correspondante
        bN est le chiffre des unité, BE des dizaine, etc...
        le code obtenu permet d'obtenir l'indice du caractère semi-graphique
        correspondant à la carte dans la liste listeCartes au début de ce fichier
        paramètre c une carte
        retourne un entier indice du caractère semi-graphique de la carte
        """
        indice=0
        if "nord" in self.mur:
            indice+=1
        if "est" in self.mur:
            indice+=2
        if "sud" in self.mur:
            indice+=4
        if "ouest" in self.mur:
            indice+=8
        return indice

    def decoderMurs(self,code):
        """
        positionne les murs d'une carte en fonction du code décrit précédemment
        paramètres c une carte
                   code un entier codant les murs d'une carte
        Cette fonction modifie la carte mais ne retourne rien
        """
        indice=[]
        Mur=set()
        codeBin=list(bin(code))
        del codeBin[0]
        del codeBin[0]
        for i in range(1,len(codeBin)+1):
            if codeBin[-i]=="1":
                indice.append(i)
        print(indice)
        if 1 in indice:
            Mur.add("nord")
        if 2 in indice:
            Mur.add("est")
        if 3 in indice:
            Mur.add("sud")
        if 4 in indice:
            Mur.add("ouest")
        self.mur=Mur

    def toChar(self):
        """
        fournit le caractère semi graphique correspondant à la carte (voir la variable listeCartes au début de ce script)
        paramètres c une carte
        """
        indiceSemiGraph=coderMurs(self)
        return listeCartes[indiceSemiGraph]

    def passageNord(self,carte2):
        """
        suppose que la carte2 est placée au nord de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par le nord
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "nord" not in self.mur and "sud" not in carte2.mur

    def passageSud(self,carte2):
        """
        suppose que la carte2 est placée au sud de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par le sud
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "sud" not in self.mur and "nord" not in carte2.mur

    def passageOuest(self,carte2):
        """
        suppose que la carte2 est placée à l'ouest de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par l'ouest
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "ouest" not in self.mur and "est" not in carte2.mur

    def passageEst(self,carte2):
        """
        suppose que la carte2 est placée à l'est de la carte1 et indique
        s'il y a un passage entre ces deux cartes en passant par l'est
        paramètres carte1 et carte2 deux carte
        résultat un booléen
        """
        return "est" not in self.mur and "ouest" not in carte2.mur