Carte.py

[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=['╬','╦','╣','╗','╩','═','╝','Ø','╠','╔','║','Ø','╚','Ø','Ø','Ø']
CarteExemple4={'Mur': {'ouest', 'nord'}, 'Trésor':2, 'pions': [1,4]}
CarteExemple2={'Mur': {'ouest'}, 'Trésor': 0, 'pions': []}
CarteExemple={'Mur': {'ouest', 'nord'}, 'Trésor': 0, 'pions': []}
CarteExemple3={'Mur': {'ouest', 'nord'}, 'Trésor': 0, 'pions': [1,4]}
CarteExemple5={'Mur': {'ouest', 'nord'}, 'Trésor': 4, 'pions': [1,4]}
CarteExemple6={'Mur': {'ouest', 'nord'}, 'Trésor': 0, 'pions': [1,4]}

def Carte( nord, est, sud, ouest, tresor=0, pions=[]):
    """
    permet de créer une carte:
    paramètres:
    nord, est, sud et ouest sont des booléens indiquant s'il y a un mur ou non dans chaque direction
    tresor est le numéro du trésor qui se trouve sur la carte (0 s'il n'y a pas de trésor)
    pions est la liste des pions qui sont posés sur la carte (un pion est un entier entre 1 et 4)
    """
    Carte={}
    Carte["Mur"]=set()
    if nord:
        Carte["Mur"].add("nord")
    if est:
        Carte["Mur"].add("est")
    if sud:
        Carte["Mur"].add("sud")
    if ouest:
        Carte["Mur"].add("ouest")
    Carte["Trésor"]=tresor
    Carte["pions"]=pions
    return Carte

assert Carte(True,False,False,True)=={'Mur': {'ouest', 'nord'}, 'Trésor': 0, 'pions': []}

def estValide(c):
    """
    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(c["Mur"])
    if NbMur==1:
        return True
    if NbMur==2:
        return True
    return False

assert estValide(CarteExemple)==True
assert estValide(CarteExemple2)==True

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

assert murNord(CarteExemple)==True
assert murNord(CarteExemple2)==False

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

assert murSud(CarteExemple)==False
assert murSud(CarteExemple2)==False

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

assert murEst(CarteExemple)==False
assert murEst(CarteExemple2)==False

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

assert murOuest(CarteExemple)==True
assert murOuest(CarteExemple2)==True

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

assert getListePions(CarteExemple)==[]

def setListePions(c,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
    """
    c["pions"]=listePions

def getNbPions(c):
    """
    retourne le nombre de pions se trouvant sur la carte
    paramètre: c une carte
    """
    return len(c["pions"])
assert getNbPions(CarteExemple)==0

def possedePion(c,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 c["pions"]

assert possedePion(CarteExemple3,3)==False
assert possedePion(CarteExemple3,4)==True

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

assert getTresor(CarteExemple)==0

def prendreTresor(c):
    """
    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=c["Trésor"]
    c["Trésor"]=0
    return AncienTrésor

assert prendreTresor(CarteExemple4)==2

def mettreTresor(c,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=c["Trésor"]
    c["Trésor"]=tresor
    return AncienTrésor

assert prendreTresor(CarteExemple5)==4

def prendrePion(c, 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 c["pions"]:
        c["pions"].remove(pion)

def poserPion(c, 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 c["pions"]:
        c["pions"].append(pion)

def tournerHoraire(c):
    """
    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 c["Mur"]:
        NvxMur.add("est")
    if "est" in c["Mur"]:
        NvxMur.add("sud")
    if "sud" in c["Mur"]:
        NvxMur.add("ouest")
    if "ouest" in c["Mur"]:
        NvxMur.add("nord")
    c["Mur"]=NvxMur

def tournerAntiHoraire(c):
    """
    fait tourner la carte dans le sens anti-horaire
    paramètres: c une carte
    Cette fonction modifie la carte mais ne retourne rien
    """
    print(c)
    NvxMur=set()
    if "nord" in c["Mur"]:
        NvxMur.add("ouest")
    if "est" in c["Mur"]:
        NvxMur.add("nord")
    if "sud" in c["Mur"]:
        NvxMur.add("est")
    if "ouest" in c["Mur"]:
        NvxMur.add("sud")
    c["Mur"]=NvxMur
    print(c)
def tourneAleatoire(c):
    """
    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(c)
        else:
            tournerHoraire(c)

def coderMurs(c):
    """
    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 c["Mur"]:
        indice+=1
    if "est" in c["Mur"]:
        indice+=2
    if "sud" in c["Mur"]:
        indice+=4
    if "ouest" in c["Mur"]:
        indice+=8
    return indice

def decoderMurs(c,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")
    c["Mur"]=Mur

def toChar(c):
    """
    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(c)
    return listeCartes[indiceSemiGraph]

def passageNord(carte1,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 carte1["Mur"] and "sud" not in carte2["Mur"]

def passageSud(carte1,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 carte1["Mur"] and "nord" not in carte2["Mur"]

def passageOuest(carte1,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 carte1["Mur"] and "est" not in carte2["Mur"]

def passageEst(carte1,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 carte1["Mur"] and "ouest" not in carte2["Mur"]