class time:
    def sleep(sec):
        for i in range(int(sec*50000)):
            i
import random
import math
dim = [30,8]
def Clear():
    print("""
"""*(dim[1]+1))

class Curseur:
    def __init__(self):
        self.LstBoutons=[]
        self.index = 0
class Bouton:
    def __init__(self,curseur,Txt):
        curseur.LstBoutons.append(self)
        self.curseur = curseur
        self.text = Txt
    def GetString(self):
        if self.curseur.LstBoutons[self.curseur.index]==self:
            return self.text
        else:
            return self.text.replace("["," ").replace("]"," ")
class Image:
    def __init__(self,data):
        self.data=data

class StringVar:
    def __init__(self,data):
        self.data=data
class Interface:
    def __init__(self):
        self.curseur = Curseur()
        self.Widgets = []
        self._lastCmd=""
    def Clear(self):
        self.Widgets = []
        self._lastCmd=""
        self.curseur.index = 0
        self.curseur.LstBoutons=[]
    def FindIndexOfWidget(self,adress):
        for i in range(len(self.Widgets)):
            if (self.Widgets[i])[0]==adress:
                return i
    def Print(self):
        Screen=[]
        for i in range(dim[1]):
            temp=[]
            for o in range(dim[0]):
                temp.append(" ")
            Screen.append(temp)

        for i in self.Widgets:
            Text = ""
            try:
                if type(i[0])==Image:
                    x,y=i[3],i[2]
                    indY=0
                    for y1 in i[0].data:
                        indX=0
                        for x1 in y1:
                            try:
                                (Screen[indY+y])[indX+x]=x1
                            except:pass
                            indX+=1
                        indY+=1
                else:
                    if type(i[0])==str:
                        Text=i[0]
                    elif type(i[0])==StringVar:
                        Text=str(i[0].data)
                    elif type(i[0])==Bouton:
                        Text=i[0].GetString()
                    if i[1]=="PlaceCenter":
                        x=int((dim[0]/2)-math.ceil(len(Text)/2))
                        x1=0
                        for lettre in Text:
                            (Screen[i[2]])[x+x1]=lettre
                            x1+=1
                    elif i[1]=="Locate":
                        x=i[3]
                        x1=0
                        for lettre in Text:
                            (Screen[i[2]])[x+x1]=lettre
                            x1+=1
            except:
                pass
        for i in Screen:
            line = ""
            for o in i:
                line+=o
            print(line)
    def Draw(self):
        self.Print()
        cmd = input()
        self._lastCmd = cmd
        if cmd=="":
            return self.curseur.index,cmd,self.curseur.LstBoutons[self.curseur.index]
        else:
            return None,cmd,None
    def RemoveWidget(self,adress):
        if type(adress)==Bouton:
            self.curseur.LstBoutons.remove(adress)
            self.curseur.index=0
        for i in range(len(self.Widgets)):
            if (self.Widgets[i])[0]==adress:
                del self.Widgets[i]
                return
    def PlaceCenter(self,obj,Ln):
        self.Widgets.append([obj,"PlaceCenter",Ln])
    def Locate(self,obj,Ln,Col):
        self.Widgets.append([obj,"Locate",Ln,Col])
    def UpdateCursor(self):
        if self._lastCmd in ["8","4","6","2"]:
            x,y=0,0
            for i in self.Widgets:
                if type(i[0])!=Bouton:
                    continue
                Text = i[0].GetString()
                if i[0]==self.curseur.LstBoutons[self.curseur.index]:
                    if i[1]=="PlaceCenter":
                        x=int((dim[0]/2)-math.ceil(len(Text)/2))
                        y=i[2]
                    elif i[1]=="Locate":
                        x=i[3]
                        y=i[2]
            direction=[None,100]
            for i in self.Widgets:
                if type(i[0])!=Bouton:
                    continue
                dis = 100
                x1,y1=0,0
                Text = i[0].GetString()
                if i[1]=="PlaceCenter":
                    x1,y1= int((dim[0]/2)-math.ceil(len(Text)/2)),i[2]
                elif i[1]=="Locate" :
                    x1,y1= i[3],i[2]
                dis = math.sqrt(((y1-y)**2)+ (x1-x)**2)
                
                if self._lastCmd=="8":
                    if y1<y and dis<direction[1]:
                        direction=[i[0],dis]
                if self._lastCmd=="2":
                    if y1>y and dis<direction[1]:
                        direction=[i[0],dis]
                if self._lastCmd=="4":
                    if x1<x and dis<direction[1]:
                        direction=[i[0],dis]
                if self._lastCmd=="6":
                    if x1>x and dis<direction[1]:
                        direction=[i[0],dis]
            if direction[0]!=None:
                self.curseur.index = self.curseur.LstBoutons.index(direction[0])
    def WaitBouttonInput(self):
        retour = None
        while retour == None:
            retour , _ , _ = self.Draw()
            if retour == None:
                self.UpdateCursor()
        return retour

interfaceValide = Interface()
def BoiteConfirmValide(txt):
    interfaceValide.Clear()
    interface = interfaceValide#Interface()
    txt = txt.split(" ")
    interface.Locate("#"*dim[0],0,0)
    y=1
    while len(txt)>0:
        msg=""
        while len(txt)>0 and len(msg)+len(txt[0])<dim[0]-3:
            msg+=" "+txt.pop(0)
        interface.Locate(msg,y,0)
        y+=1
    interface.Locate("#"*dim[0],dim[1]-1,0)
    interface.Locate(Bouton(interface.curseur," [OUI] "),dim[1]-1,int((dim[0]/4)-math.ceil(7/2))+1)
    interface.Locate(Bouton(interface.curseur," [NON] "),dim[1]-1,int((3*dim[0]/4)-math.ceil(7/2)))
    return interface.WaitBouttonInput() == 0

interfaceConfirmOK = Interface()
def BoiteConfirmOK(txt):
    interfaceConfirmOK.Clear()
    interface = interfaceConfirmOK#Interface()
    txt = txt.split(" ")
    interface.Locate("#"*dim[0],0,0)
    y=1
    while len(txt)>0:
        msg=""
        while len(txt)>0 and len(msg)+len(txt[0])<dim[0]-3:
            msg+=" "+txt.pop(0)
        interface.Locate(msg,y,0)
        y+=1
    interface.Locate("#"*dim[0],dim[1]-1,0)
    interface.PlaceCenter(Bouton(interface.curseur," [OK] "),dim[1]-1)
    interface.Draw()
    return True

def MainMenu():
    Clear()
    interface = Interface()
    Titre = "The Master Maze"
    interface.PlaceCenter((len(Titre)+2)*"=",0)
    interface.PlaceCenter(" "+Titre+" ",1)
    interface.PlaceCenter((len(Titre)+2)*"=",2)
    interface.PlaceCenter(Bouton(interface.curseur,"[Commencer une partie]"),4)
    interface.PlaceCenter(Bouton(interface.curseur,"[Entrer un code]      "),5)
    #interface.PlaceCenter(Bouton(interface.curseur,"[Comment Jouer ?]     "),6)
    interface.PlaceCenter(Bouton(interface.curseur,"[Quitter]             "),7)
    return interface.WaitBouttonInput()

#BoiteConfirmOK("Coucou ceci est un test pour voir si ca fonctionne je doute un peu")

#BoiteConfirmValide("Coucou ceci est un test pour voir si ca fonctionne je doute un peu")

#MainMenu()

class C_Maze:
    UP = (0, -1)
    DOWN = (0, 1)
    LEFT = (-1, 0)
    RIGHT = (1,0)

    def __init__(self, width, height, seed, symbols=None):
            self.init_symbols(symbols)
            self.width = width
            self.height = height
            self.seed = seed
            self.path = [] # current path taken
            self.player = (0,0) # players position
            self.grid =[]
            for col in range(0, width):
                temp=[]
                for row in range(0,height):
                    temp.append(width*row + col)
                self.grid.append(temp)
            self.portals = {}
            self.generate() 
    

    def __repr__(self):
        return self.to_str()

    def to_str(self):   
        s=''
        for col in range(0, self.width):
            s+=self.wall_c + self.wall_h
        
        s+=self.wall_c+'\n'
        # wall if region not the same   
        for row in range(0,self.height):    
            # draw S for start if at (0,0)
            if row == 0:
                s+=self.wall_v + self.start
            else:
                s+=self.wall_v + self.empty 
    
            # draw | if no portal between [row][col] and [row][col-1]   
            for col in range(1, self.width):    
                # if  theres a portal between cell and left cell
                if self.grid[col-1][row] in self.portals[self.grid[col][row]]:
                    # if portal remove wall
                    c = self.empty
                else:
                    # if not portal draw vertical wall
                    c = self.wall_v
                # if at [width-1][height-1] draw end marker or cell
                if row == self.height-1 and col == self.width-1:
                    c += self.end   
                else: # draw cell
                    c += self.empty             
                s += c  
            s+=self.wall_v +'\n'
            # draw - if not portal between [row][col] and [row+1][col]
            for col in range(0, self.width):
                # if edge above (visually below)
                c =self.wall_h
                key = self.grid[col][row]   
                # if not at last row, and theres a portal between cell and above cell
                if row+1 < self.height and self.grid[col][row+1] in self.portals[key]:
                        c = self.empty
                s+=self.wall_c + c
            s+=self.wall_c +'\n'
        s+=self.empty
        return s


    def init_symbols(self, symbols):
        self.start = symbols['start'] 
        self.end =  symbols['end']
        self.wall_h = symbols['wall_h'] 
        self.wall_v = symbols['wall_v'] 
        self.wall_c = symbols['wall_c']   
        self.empty = ' '
    
    def generate(self):
        edges_ordered = [ ]
        for row in range(0, self.height):
            for col in range(0, self.width):    
                cell = (col, row)
                left_cell = (col-1, row)
                down_cell = (col, row-1)
                near = []
                if col > 0:
                    near.append((left_cell, cell))
                if row > 0:
                    near.append( (down_cell, cell))
                edges_ordered.extend(near)

        random.seed(self.seed)
        edges = []
        while len(edges_ordered) > 0:
            edges.append(edges_ordered.pop(random.randint(0,len(edges_ordered))-1))
        disjoint_set = DisjointSet()
        for row in range(0, self.height):
            for col  in range(0,self.width):
                key = self.grid[col][row]
                disjoint_set.make_set(key)
                self.portals[key] = {}
        edge_count = 0
        key_count = self.grid[self.width-1][self.height-1] # last key   
        while edge_count < key_count:
            edge = edges.pop()
            key_a = self.grid[edge[0][0]][edge[0][1]]
            key_b = self.grid[edge[1][0]][edge[1][1]]
            set_a = disjoint_set.find(key_a)
            set_b = disjoint_set.find(key_b)
            if set_a != set_b:
                edge_count+=1   
                self.portals[key_a][key_b] = True 
                self.portals[key_b][key_a] = True 
                disjoint_set.union(set_a, set_b)


            
class DisjointSet:
    class Element:
        def __init__(self, key):
            self.key = key
            self.parent = self
            self.rank = 0
        
        def __eq__(self, other):
            return self.key ==  other.key
        def __ne__(self, other):
            return self.key != other.key
 
    def __init__(self):
        self.tree = {}
    
    def make_set(self, key):
        e = self.Element(key)
        if not key in self.tree.keys():
            self.tree[key] = e

            
    def find(self, key):
        if key in self.tree.keys():
            element = self.tree[key]
            if element.parent != element:
                element.parent  = self.find(element.parent.key)
            return element.parent

    
    def union(self, element_a, element_b):
        root_a = self.find(element_a.key)
        root_b = self.find(element_b.key)
        if root_a != root_b:
            if root_a.rank < root_b.rank:
                root_a.parent = root_b
            elif root_a.rank > root_b.rank:
                root_b.parent = root_a
            else:
                root_b.parent = root_a
                root_a.rank+=1


def GetWidth(name):
    w=0
    for i in name.split("\n"):
        if len(i)>w:
            w=len(i)
    return w
def GetHeight(name):
    return len(name.split("\n"))
def GetImage(name):
    if name[0]=="\n":
        name=name[1:]
    w,h=GetWidth(name),GetHeight(name)
    Lst = name.split("\n")
    Screen=[]
    for i in range(h):
        temp=[]
        for o in range(w):
            temp.append(" ")
        Screen.append(temp)
    Y=0
    for i in Lst:
        X=0
        for o in i:
            (Screen[Y])[X]=o
            X+=1
        Y+=1
    return Screen
class Images:
    
    player1=Image(GetImage("""
 |
_|_ o __
 I /|\\)_)
   / \\
"""))

    player2=Image(GetImage("""
 |
_|_ o .-.
 I /|\\|.|
   / \\!_!
"""))

    player3=Image(GetImage("""
 |     _
_|_ o | |
 I /|\\)o(
   / \\|_|
"""))

    chest=Image(GetImage("""
  __________
 /\\____;;___\\
| /         /
./_________/
|\\         \\
| |---------|
\\ |    ))   |
 \\|_________|
"""))

    Monster1=Image(GetImage("""
     /--------\\
    | o     o  \\
  ./| .vvvvv.  |\\
 / /| |     |  |\\\\
//' | `^vvvv'  | \\\\
    |          |  ~
     7        /
    /    /\\   \\
"""))

    Monster2=Image(GetImage("""
 __           __
/  \\  _____  /  \\
\\__/\\/     \\/\\__/
     |     |
  __/ \\_o_/ \\__
 /  \\  { }  /  \\
 \\__/       \\__/
"""))

    

class Dialogues:
    Player1="Pierre"
    Player2="Paul"
    Player3="Jack"

    Spawn1="Un monstre apparait ! Preparez-vous a vous battre !"

    Mort1="Vous ne pouvez pas selectionner un personnage mort"

    Mechant1="Ha ! Je vous tiens !"
    Mechant2="Vous etes foutu ! Je vais vous tuer"
    Mechant3="VOUS NE PASSEREZ PAS !"

    CombatVct = "Felicitations vous avez gagne le combat !"
    GameOver = "Vous avez perdu !"

    chest = "C'est l'heure de la loterie !"

    scenario1=["Tout commence dans un Donjon. Vous avez ete enfermes pour une raison que l'on ignore,",
     "mais vous devez absolument vous enfuire pour survivre.",
     "Au cours, de ce periple vous dervrez vous battre.",
     "Vous etes une equipe de 3 personnes dont vous devrez alterner"]

    scenario2=["Felicitations vous etes parvenus a arriver jusqu'a la sortie.",
               "Vos trois personnages sont enfin libres !",
               "Liberes, DELIVREEEEEEEES... Hurm Hurm un peu plus de serieux et bravo !",
               "Merci d'avoir joue"]


class Block:
    def __init__(self):
        self.image=Image([])
    def Get(self):
        return self.image

class Wall(Block):
    def __init__(self):
        Block.__init__(self)
        self.image=Image([["#","#"],["#","#"]])
    def Get(self):
        return self.image
class Door(Block):
    def __init__(self,interface):
        Block.__init__(self)
        self.Bouton = Bouton(interface.curseur,"[@]")
    def Get(self):
        return self.Bouton

class Epee:
    def __init__(self,name,degat):
        self.name=name
        self.degat=degat
        

PetitGlaive = Epee("Petit Glaive",3)
Glaive = Epee("Glaive",5)
EpeeRouille = Epee("Epee Rouillee",8)
EpeeDuSoldat = Epee("Epee Du Soldat",12)
MasterSword=Epee("Master Sword",15)
Swords=[PetitGlaive,Glaive,EpeeRouille,EpeeDuSoldat,MasterSword]
    


class Player:
    def __init__(self,index):
        self.name=([Dialogues.Player1,Dialogues.Player2,Dialogues.Player3])[index]
        imgTemp=([Images.player1,Images.player2,Images.player3])[index]
        self.image = imgTemp
        self.life=10
        self.maxLife=10
        self.Epee=PetitGlaive

    def AddLife(self,life):
        self.life+=life
        if self.life>self.maxLife:
            self.life=self.maxLife

class Monster:
    def __init__(self, imageString,life,attack):
        self.image = imageString
        self.life=life
        self.attack = attack

    def ApplyDegat(self,degat):
        self.life-=degat
        return self.life<=0

interfaceSwitchChest = Interface()
interfaceChest = Interface()
class Chest:
    def __init__(self,plateau):
        self.plateau = plateau
        self.InitInterfaceSelect()
    def InitInterfaceSelect(self):
        interfaceSwitchChest.Clear()
        self.interfaceSwitch = interfaceSwitchChest#Interface()
        self.interfaceSwitch.Locate(Images.player1,1,0)
        self.interfaceSwitch.Locate(Images.player2,1,int(dim[0]//3)+1)
        self.interfaceSwitch.Locate(Images.player3,1,int(dim[0]*2//3)+1)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player1+"] "),dim[1]-2,0)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player2+"] "),dim[1]-2,int(dim[0]//3)+1)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player3+"] "),dim[1]-2,int(dim[0]*2//3)+1)
        self.interfaceSwitch.PlaceCenter("Qui recevra le cadeau ?",0)

    def Start(self):
        interfaceChest.Clear()
        self.interface = interfaceChest#Interface()
        self.interface.Locate(Images.chest,0,0)
        self.interface.PlaceCenter(Dialogues.chest,0)
        
        self.actionB=Bouton(self.interface.curseur,"[OK]")
        self.interface.PlaceCenter(self.actionB,dim[1]-1)
        self.interface.WaitBouttonInput()

        lst=["une Epee","Plus de Coeurs"]
        st=30
        n=random.randint(st,st+10+len(lst)*3)
        for i in range(n):
            print("-> "+lst[i%len(lst)])
            time.sleep(0.5*(i/n))
        time.sleep(1)
        BoiteConfirmOK("Vous avez gagne "+lst[i%len(lst)])
        
        index=i%len(lst)
        if index==0:
            swo = Swords[random.randint(0,len(Swords)-1)]
            BoiteConfirmOK("Vous avez gagne l'epee : "+ swo.name)
            
            retour = self.interfaceSwitch.WaitBouttonInput()
            player = self.plateau.players[retour]
            
            if player.Epee.degat>swo.degat:
                BoiteConfirmOK("l'epee que vous avez reçue est moins puissante, par consequent vous l'avez jetee")
            else:
                player.Epee=swo
        elif index == 1:
            retour = self.interfaceSwitch.WaitBouttonInput()
            player = self.plateau.players[retour]
        
            player.maxLife+=3
            if player.maxLife>99:
                player.maxLife=99
            player.life = player.maxLife

interfaceActFight = Interface()
interfaceSwitchFight = Interface()
interfaceFight = Interface()
class Fight:
    def __init__(self,plateau,monster):
        self.plateau = plateau
        self.monster = monster
        self.PlayerIndex=0
        if self.plateau.players[0].life>0:
            self.PlayerIndex=0
        elif self.plateau.players[1].life>0:
            self.PlayerIndex=1
        elif self.plateau.players[2].life>0:
            self.PlayerIndex=2
        interfaceFight.Clear()
        self.interface = interfaceFight#Interface()
        self.interface.Locate(monster.image,0,10)
        texte=Dialogues.Mechant3
        cont=Bouton(self.interface.curseur," [Continuer]")
        self.interface.Locate(cont,dim[1]-1,0)
        self.interface.Locate(texte,dim[1]-2,0)
        self.interface.Draw()
        self.interface.RemoveWidget(cont)
        self.interface.RemoveWidget(texte)
        self.interface.RemoveWidget(monster.image)
        BoiteConfirmOK(Dialogues.Spawn1)
        
        self.InitInterfaceAction()
        self.InitInterfaceSwitch()
        
        self.interface.Locate(monster.image,1,15)
        self.interface.Locate(self.plateau.players[self.PlayerIndex].image,2,2)
        self.life = StringVar(str(self.plateau.players[self.PlayerIndex].life)+" <3")
        self.interface.Locate(self.life,0,0)
        
        self.lifeMonster = StringVar(str(monster.life)+" <3")
        self.interface.Locate(self.lifeMonster,0,dim[0]-8)
        
        self.actionB=Bouton(self.interface.curseur,"[Actions]")
        self.interface.Locate(self.actionB,dim[1]-1,1)
        

    def InitInterfaceAction(self):
        interfaceActFight.Clear()
        self.interfaceAct = interfaceActFight#Interface()
        self.interfaceAct.PlaceCenter("Choisissez une action",0)
        self.interfaceAct.PlaceCenter(Bouton(self.interfaceAct.curseur,"[Attaquer]             "),2)
        self.interfaceAct.PlaceCenter(Bouton(self.interfaceAct.curseur,"[Changer de personnage]"),3)
        self.interfaceAct.PlaceCenter(Bouton(self.interfaceAct.curseur,"[Se proteger]          "),4)
    def InitInterfaceSwitch(self):
        interfaceSwitchFight.Clear()
        self.interfaceSwitch = interfaceSwitchFight#Interface()
        self.interfaceSwitch.Locate(Images.player1,0,0)
        self.interfaceSwitch.Locate(Images.player2,0,int(dim[0]//3)+1)
        self.interfaceSwitch.Locate(Images.player3,0,int(dim[0]*2//3)+1)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player1+"] "),dim[1]-3,0)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player2+"] "),dim[1]-3,int(dim[0]//3)+1)
        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," ["+Dialogues.Player3+"] "),dim[1]-3,int(dim[0]*2//3)+1)

        self.interfaceSwitch.Locate(Bouton(self.interfaceSwitch.curseur," [Retour] "),dim[1]-1,int(dim[0]*2//3)+2)
    def InterfaceSwitch(self):
        while True:
            retour = self.interfaceSwitch.WaitBouttonInput()
            if retour==3:
                return False
            if self.plateau.players[retour].life<=0:
                BoiteConfirmOK(Dialogues.Mort1)
            else:
                self.interface.RemoveWidget(self.plateau.players[self.PlayerIndex].image)
                self.PlayerIndex=retour
                self.interface.Locate(self.plateau.players[self.PlayerIndex].image,2,2)
                return True
    def Attack(self):
        prob=5
        if self.PlayerIndex==1:
            prob+=2
        n=random.randint(0,10)<=prob
        if n:
            degat=self.plateau.players[self.PlayerIndex].Epee.degat
            BoiteConfirmOK("Vous avez fait "+str(degat)+" points de degat")
            prob=3
            if self.PlayerIndex==2:
                prob+=2
            n=random.randint(0,10)<=prob
            if n:
                critique = 3
                if self.PlayerIndex==2:
                    critique+=2
                BoiteConfirmOK("Coup Critique : Vous avez touche un point faible du monstre, par consequent vous avez fait "+str(critique)+" points de degat suplementaire")
                degat+= critique
            return self.monster.ApplyDegat(degat)
        else:
            BoiteConfirmOK("Vous avez manque votre attaque")
            return False
    def PlayersIsAlive(self):
        n=False
        for i in self.plateau.players:
            n=n or i.life>0
        return n
    def Start(self):
        while self.monster.life>0 and self.PlayersIsAlive():
            self.lifeMonster.data = str(self.monster.life)+" <3"
            self.life.data = str(self.plateau.players[self.PlayerIndex].life)+" <3"
            self.interface.Draw()
            select = False
            ProbaEnn = 5
            if self.PlayerIndex==0:
                ProbaEnn-=1
            while not select:
                retour = self.interfaceAct.WaitBouttonInput()
                if retour == 0:
                    select=True
                    if self.Attack():
                        break
                elif retour == 1:
                    select=self.InterfaceSwitch()
                elif retour == 2:
                    select=True
                    ProbaEnn -= 3
                    self.plateau.players[self.PlayerIndex].AddLife(1)
                    if self.PlayerIndex==0:
                        self.plateau.players[self.PlayerIndex].AddLife(1)
                    break
            if self.monster.life<=0:
                break
            self.lifeMonster.data = str(self.monster.life)+" <3"
            self.life.data = str(self.plateau.players[self.PlayerIndex].life)+" <3"
            self.interface.Locate("Waiting...",dim[1]-1,1)
            self.interface.Print()
            self.interface.RemoveWidget("Waiting...")
            time.sleep(2)
            BoiteConfirmOK("L'ennemi attaque !")
            n=random.randint(0,10)<=ProbaEnn
            if n:
                degat=self.monster.attack
                if self.PlayerIndex==1:
                    degat-=1
                self.plateau.players[self.PlayerIndex].life-=degat
                BoiteConfirmOK("Vous avez pris "+str(degat)+" points de degat")
            else:
                BoiteConfirmOK("L'ennemi a rate son attaque")
            if self.plateau.players[self.PlayerIndex].life<=0:
                BoiteConfirmOK(([Dialogues.Player1,Dialogues.Player2,Dialogues.Player3])[self.PlayerIndex]+" est mort !")
                self.interface.RemoveWidget(self.plateau.players[self.PlayerIndex].image)
                if self.plateau.players[0].life>0:
                    self.PlayerIndex=0
                elif self.plateau.players[1].life>0:
                    self.PlayerIndex=1
                elif self.plateau.players[2].life>0:
                    self.PlayerIndex=2
                self.interface.Locate(self.plateau.players[self.PlayerIndex].image,2,2)
        if self.monster.life<=0:
            BoiteConfirmOK(Dialogues.CombatVct)
            return True
        else:
            BoiteConfirmOK(Dialogues.GameOver)
            return False


interfaceInv = Interface()
interfacePlateau = Interface()
interfaceMapEXT = Interface()

class Plateau:
    def __init__(self,x,y,maze,seed):
        self.players=[Player(0),Player(1),Player(2)]
        self.Map = maze
        self.X = x
        self.Y = y
        self.seed=seed
        self.difficulte = 1
        self.Blocks = []
        self.interface = interfacePlateau#Interface()
        self.DontSpawn = [str(self.X)+":"+str(self.Y)]
        self.InventaireInit()

    def InventaireInit(self):
        self.interfaceInv = interfaceInv#Interface()
        self.interfaceInv.PlaceCenter(Bouton(self.interfaceInv.curseur,"[Retour]     "),2)
        self.interfaceInv.PlaceCenter(Bouton(self.interfaceInv.curseur,"[Sauvegarder]"),3)
        self.interfaceInv.PlaceCenter(Bouton(self.interfaceInv.curseur,"[Carte]      "),4)
        self.interfaceInv.PlaceCenter(Bouton(self.interfaceInv.curseur,"[Quitter]    "),6)
    def ClearRoom(self):
        self.interface.Clear()
        self.Blocks = []
        for i in range(dim[1]//2):
            temp=[]
            for o in range(dim[0]//2):
                temp.append(Block())
            self.Blocks.append(temp)

    def PrintMap(self):
        NewImg=[]
        y=0
        for i in self.Map:
            temp=[]
            x=0
            for o in i:
                if o=="S":
                    temp.append("D")
                elif o=="X":
                    temp.append("F")
                elif self.X==x and self.Y==y:
                    temp.append("X")
                else:
                    temp.append(o)
                x+=1
            NewImg.append(temp)
            y+=1
        interfaceMapEXT.Clear()
        interfaceMap = interfaceMapEXT#Interface()
        interfaceMap.Locate(Image(NewImg),-1,-1)
        interfaceMap.Locate(Bouton(interfaceMap.curseur,""),dim[1]-1,0)
        interfaceMap.Draw()
    def MakeRoom(self):
        self.ClearRoom()
        lst= ["|","-","+"]
        print(self.Y,self.X)
        if len(self.Map)>self.Y+1 :
            if (self.Map[self.Y+1])[self.X] in lst:
                for i in range(len(self.Blocks[0])):
                    (self.Blocks[-1])[i]=Wall()
            else:
                (self.Blocks[-1])[dim[0]//4]=Door(self.interface)
        if 0<=self.Y-1 :
            if (self.Map[self.Y-1])[self.X] in lst:
                for i in range(len(self.Blocks[0])):
                    (self.Blocks[0])[i]=Wall()
            else:
                (self.Blocks[0])[dim[0]//4]=Door(self.interface)
        if 0<=self.X-1 :
            if (self.Map[self.Y])[self.X-1] in lst:
                for i in range(len(self.Blocks)):
                    (self.Blocks[i])[0]=Wall()
            else:
                (self.Blocks[dim[1]//4])[0]=Door(self.interface)
        if len(self.Map[0])>self.X :
            if (self.Map[self.Y])[self.X+1] in lst:
                for i in range(len(self.Blocks)):
                    (self.Blocks[i])[-1]=Wall()
            else:
                (self.Blocks[dim[1]//4])[-1]=Door(self.interface)
        (self.Blocks[0])[0]=Wall()
        (self.Blocks[-1])[0]=Wall()
        (self.Blocks[0])[-1]=Wall()
        (self.Blocks[-1])[-1]=Wall()


        indY=0
        for i in self.Blocks:
            indX=0
            for o in i:
                self.interface.Locate(o.Get(),indY*2,indX*2)
                indX+=1
            indY+=1
    def Spawn(self):
        if not str(self.X)+":"+str(self.Y) in self.DontSpawn:
            self.DontSpawn.append(str(self.X)+":"+str(self.Y))
            n=random.randint(0,1)
            if n==0:
                monst = Monster(([Images.Monster1,Images.Monster2])[random.randint(0,1)],int(5*self.difficulte),int(2*self.difficulte))
                fight=Fight(self,monst)
                vict = fight.Start()
                self.difficulte +=0.1
                    
                return vict
            elif n>=1:
                chest=Chest(self)
                chest.Start()
                return True
            #elif n==1:Nothing
        return True

    def GetInfos(self):
        data=[self.seed,
         self.X,
         self.Y,
         min(int(self.difficulte),9),
         self.players[0].maxLife,
         Swords.index(self.players[0].Epee),
         self.players[1].maxLife,
         Swords.index(self.players[1].Epee),
         self.players[2].maxLife,
         Swords.index(self.players[2].Epee)]
        
        poid=[2,
         2,
         2,
         1,
         2,
         1,
         2,
         1,
         2,
         1]

        return data,poid
    
    def Save(self):
        data,poid=self.GetInfos()
        res=""
        for i in range(len(data)):
            res+="00"[:poid[i]-len(str(data[i]))]+str(data[i])
        return res

    def Load(self,string):
        _,poid=self.GetInfos()
        data=[]
        i=0
        while len(string)>0:
            data.append(int(string[:poid[i]]))
            string=string[poid[i]:]
            i+=1
        self.seed=data[0]
        self.X=data[1]
        self.Y=data[2]
        self.difficulte=data[3]
        self.players[0].maxLife=data[4]
        self.players[0].Epee = Swords[data[5]]
        self.players[1].maxLife=data[6]
        self.players[1].Epee = Swords[data[7]]
        self.players[2].maxLife=data[8]
        self.players[2].Epee = Swords[data[9]]
        
        self.DontSpawn.append(str(self.X)+":"+str(self.Y))
        
    def Inventaire(self):
        retour=self.interfaceInv.WaitBouttonInput()
        if retour == 0:
            return True
        elif retour ==1:
            BoiteConfirmOK("voici le code qu'il faut noter : "+str(self.Save()))
            return True
        elif retour ==2:
            self.PrintMap()
            return True
        elif retour ==3:
            n=BoiteConfirmValide("Etes-vous sur de vouloir quitter ?")
            return not n
    def Move(self):
        if (self.Map[self.Y])[self.X]=="X":
            for i in Dialogues.scenario2:
                BoiteConfirmOK(i)
            return False
        self.MakeRoom()
        self.interface.Print()
        #time.sleep(1)
        
        battle = self.Spawn()
        if not battle:
            return False

        retour = None
        while retour == None:
            retour , cmd , _ = self.interface.Draw()
            if retour == None:
                self.interface.UpdateCursor()
            if cmd == "9":
                n=self.Inventaire()
                return n
        
        bouton = self.interface.curseur.LstBoutons[retour]
        index = self.interface.FindIndexOfWidget(bouton)
        widget =self.interface.Widgets[index]
        Wx,Wy=widget[3],widget[2]
        print(Wx,Wy,self.X,self.Y)
        if Wx==0:
            self.X-=1
        elif Wx==dim[0]-2:
            self.X+=1
        elif Wy==0:
            self.Y-=1
        elif Wy==dim[1]-2:
            self.Y+=1
        return True

    
def Start(seed=0,code=None):
    symbols = {
    # default symbols
    'start' : 'S',
    'end' : 'X',
    'wall_v'  : '|',
    'wall_h' : '-',
    'wall_c' : '+',
    'empty' : ' '
}
    Tmaze = str(C_Maze(15,4,0,symbols))
    print(Tmaze)
    Maze = []
    x,y=0,0
    indY=0
    for i in Tmaze.split("\n"):
        temp=[]
        indX=0
        for o in i:
            if o=='S':
                x,y=indX,indY
            temp.append(o)
            indX+=1
        Maze.append(temp)
        indY+=1
    if len(Maze[-1])<len(Maze[0]):
        del Maze[-1]
    plateau = Plateau(x,y,Maze,seed)
    if code!=None:
        plateau.Load(code)
    
    return plateau

_quit = False
if dim[0]%2!=0 or dim[1]%2!=0:
    BoiteConfirmOK("La resolution de votre ecran n'est pas un multiple de 2")
    _quit = True
while not _quit:
    choix = MainMenu()
    _quit=True
    if choix == 0:
        for i in Dialogues.scenario1:
            BoiteConfirmOK(i)
        seed = random.randint(0,99)
        plateau=Start(seed)#(self.seed)
        res = True
        while res:
            res=plateau.Move()
    elif choix==1:
        Clear()
        code=input("Entrez le code:")
        plateau=Start(code=code)
        res = True
        while res:
            res=plateau.Move()
    elif choix==2:
        _quit=True
    #self.UI_interface = Interface()