tp.py

tp flor

class Laberinto(object):
	def __init__(self, parent=None):
		self.fil=5
		self.col=5
		self.parent = parent
        self.laberinto=[[[1,1,0,0],[0,1,0,1],[0,1,0,1],[0,1,0,1],[0,1,1,0]],[[1,1,0,0],[0,1,0,1],[0,1,1,0],[1,1,0,1],[0,1,0,0]],[[0,1,0,0],[0,1,0,1],[0,1,0,1],[0,1,1,1],[1,1,1,0]],[[1,1,0,0],[0,1,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,0]],[[0,0,0,0],[0,1,0,1],[0,1,0,1],[0,1,1,1],[1,0,1,0]]]
        self.posQueso=(1,0)
        self.posRata=(0,0)
	##### interfaz (metodos publicos)
    def cargar(self,fn):
        #try:
        with open("fn","r") as f:
            self.dim=f.readline()
            self.laberinto=[f.readlines()]
        f.close()
        b=self.dim.replace("Dim","")
        b=b.replace("(","")
        b=b.replace(")","")
        self.dimensiones=b.split(",")
        self.fil=int(self.dimensiones[0])#numero de filas del laberinto
        self.col=int(self.dimensiones[1])#numero de columnas del laberinto
       # self.dim=lista.pop(0) #saco el elemento 0 (me dice la dimension), tiene que ser un string "Dim(10,10)"
        #me falta construir array con la dimension del laberinto
        #seteamos las posiciones iniciales de la rata y del queso respectivamente
        self.posRata=(0,0)
        self.posQueso=(len(self.laberinto-1),len(self.laberinto[0]-1))
        resetear(self)
        return self.laberinto
    #except IOError:
    #    sys.stderr.write( "laberinto.py - Error: Could not open file )
     #   sys.exit(-1)
       
    def tamano(self):
        return (self.fil,self.col)#devuelve [10,10]

    def resetear(self): #accedo al diccionario por las claves "visitada" y "caminoActual"
        #pero las posiciones que estan ahi, con que clave las reemplazo?
        self.diccionario = {} #quitamos tods las posiciones tanto visitadas como camino actual
        #voy recorriendo el laberinto y llenando todas las posiciones (i,j) con visitada:false y caminoactual:false
        for i in range (len(self.laberinto)):
            for j in range (len(self.laberinto[i])):
                self.diccionario[(i,j)]={"visitada": False, "caminoactual": False} #armamos varios diccionarios dentro del diccionario 
        return self.diccionario
   
    def getPosicionRata(self):
        return self.posRata #pos rata tiene que serr una lista para usar
    #funcion esposRata
   
    def getPosicionQueso(self):
        return self.posQueso

    # devuelve true si:
    # esta dentro de los limites del laberinto Y
    # no es una pared
    def esPosicionValida(i, j): 
        estaDentroDeX = 0 <= i < self.dimensiones[0]
        estaDentroDeY = 0 <= j < self.dimensiones[1]
        arriba = getInfoCelda(self, i, j + 1)
        abajo = getInfoCelda(self, i, j - 1)
        izquierda = getInfoCelda(self, i - 1)
        derecha = getInfoCelda(self, i + 1, j)
        esPared = izquierda[0] or arriba[1]  or derecha[2] or abajo[3]
        return estaDentroDeX and estaDentroDeY and not esPared

    def setPosicionRata(self, i, j):
        if esPosicionValida(i, j):
            self.posRata = (i, j)
        return esPosicionValida(i, j)
   
    def setPosicionQueso(self, i, j):
        if esPosicionValida(i, j):
            self.posQueso = (i, j)
        return esPosicionValida(i, j)
           
    def esPosicionRata(self, i, j):
        return (i == self.posRata[0] and j == self.posRata[1])

    def esPosicionQueso(self,i,j):
        return (i == self.posQueso[0] and j == self.posQueso[1])
       
    def get(self,i,j):#1 es que hay pared
        self.laberinto[i][j]# deberia devolver una lista tipo [0,0,1,0]
        res=[] #le voy appendeando los booleanos
        for k in range (4):
            res.append(self.laberinto[i][j][k]==1)
        return res
   
    def getInfoCelda(self,i,j):
        if (i,j) in self.diccionario:
            return self.diccionario[(i,j)] #devuelve todo lo que 
        #hay adentro de la clave (i,j)
        
    def resuelto(self):#devuelve booleano
        return self.posRata == self.posQueso

    # def resolver(self):
    #     self.diccionario[(self.posRata[0],self.posRata[1])]["caminoactual"]=True 
    #     #poner la posRata como camino actual en el diccionario
    #     #en el caso de que la posicion actual este visitada y todas las otras posiciones tengan pared o esten visitadas, se pierde el juego y devuelve False
    #     if self.diccionario[(i,j)]["visitada"] and (self.laberinto[i][j][2]==1 or self.diccionario[(i,j+1)]["visitada"]) and (self.laberinto[i][j][3]==1 or self.diccionario[(i+1,j)]["visitada"]) and (self.laberinto[i][j][0]==1 or self.diccionario[(i,j-1)]["visitada"]) and (self.laberinto[i][j][1]==1 or self.diccionario[(i-1,j)]["visitada"]):
    #         return False
    #     if self.laberinto[i][j][2]==0 and not self.diccionario[(i,j+1)]["visitada"] and (self.diccionario[(i,j)]["visitada"] or not self.diccionario[(i,j+1)]["caminoactual"]):
    #         self.posRata==self.laberinto[i][j+1] #derecha falta CAMINO ACTUAL
    #         if not resuelto(self):
    #             return resolver(self)
    #         else:
    #             return True
    #     if self.laberinto[i][j][3]==0 and not self.diccionario[(i+1,j)]["visitada"] and (self.diccionario[(i,j)]["visitada"] or not self.diccionario[(i+1,j)]["caminoactual"]):
    #         self.posRata==self.laberinto[i+1][j] #abajo
    #         if not resuelto(self):
    #             return resolver(self)
    #         else:
    #             return True
    #     if self.laberinto[i][j][0]==0 and not self.diccionario[(i,j-1)]["visitada"] and (self.diccionario[(i,j)]["visitada"] or not self.diccionario[(i,j-1)]["caminoactual"]):
    #         self.posRata==self.laberinto[i][j-1] #izq
    #         if not resuelto(self):
    #             return resolver(self)
    #         else:
    #             return True
    #     if self.laberinto[i][j][1]==0 and not self.diccionario[(i-1,j)]["visitada"] and (self.diccionario[(i,j)]["visitada"] or not self.diccionario[(i-1,j)]["caminoactual"]):
    #         self.posRata==self.laberinto[i-1][j] #arriba
    #         if not resuelto(self):
    #             return resolver(self)
    #         else:
    #             return True
    #     else:
    #         #poner como visitada 
    #         self.diccionario[(i,j)]["visitada"]=True
    #         return resolver(self)

    def posicionEstaVisitada(self, i, j):
        # TODO: verificar si posicion existe primero porque sino explota
        return diccionario[i][j]["visitada"]

    def posicionEsCaminoActual (self, i,j):
        # TODO: verificar si posicion existe primero porque sino explota
        return diccionario[i][j]["caminoactual"]

    def marcarPosicionDeLaRataComoCaminoActual(self, i, j):
        # TODO: verificar si posicion existe primero porque sino explota
        # TODO: sacarle el true a visitada
        diccionario[i][j]["caminoactual"] = True
        return

    def marcarPosicionDeLaRataComoVisitada(self,i,j):
        # TODO: verificar si posicion existe primero porque sino explota
        # TODO: sacarle el true a camino actual
        diccionario[i][j]["visitada"] = True
        return

    def moverRataSiSePuede(self, i, j):
        sePudo = not posicionEsCaminoActual(self, i, j) and not posicionEsVisitada(self, i, j) and setPosicionRata(self, i, j)
        if sePudo:
            marcarPosicionDeLaRataComoCaminoActual(self, i, j)
        return sePudo

    def resolver(self):
        marcarPosicionActualComoCaminoActual(self)
        if resolverUtil(self) == False:
            return False
        return True
    
    def resolverUtil(self):
        if resuelto(self):
            return True
        
        # derecha
        if moverRataSiSePuede(self, self.posRata.i + 1, self.posRata.j):
            resolverUtil(self)
        # izquierda
        elif moverRataSiSePuede(self, self.posRata.i - 1, self.posRata.j):
            resolverUtil(self)
        # arriba
        elif moverRataSiSePuede(self, self.posRata.i, self.posRata.j + 1):
            resolverUtil(self)
        # abajo
        elif moverRataSiSePuede(self, self.posRata.i, self.posRata.j - 1):
            resolverUtil(self)
        
        marcarPosicionDeLaRataComoVisitada(self, self.posRata.i, self.posRata.j)
        return False

            
            #volver al primer camino actual que encuentres 
	##### auxiliares (metodos privados)
##### auxiliares (metodos privados)

	def _redibujar(self):
	    if self.parent is not None:
	        self.parent.update()

#EJEMPLO DE DICCIONARIO
#diccionario={(2,2):{"visitada":True, "caminoactual":False},(3,3):{"visitada":True, "caminoactual":False}}
#print(diccionario[(3,3)]["visitada"])