641 lines
24 KiB
Python
641 lines
24 KiB
Python
#! /usr/bin/env python3
|
|
|
|
# this module is under licence MIT @ Tiemen DUVILLARD 2020
|
|
# for all questions, comments, bugs: duvillard.tiemen@gmail.com
|
|
|
|
from random import choice, randrange
|
|
|
|
# Representation of maze :
|
|
# A labyrinth is a set of 2 door panels.
|
|
# For a maze 5*5 :
|
|
# Theory : ## Example :
|
|
# L = [[[a, b, c, d], # vertical doors ## L = [[[1, 1, 1, 1], # vertical doors
|
|
# [e, f, g, h], ## [1, 0, 1, 0],
|
|
# [i, j, k, l], ## [0, 1, 0, 1],
|
|
# [m, n, o, p], ## [0, 0, 0, 0],
|
|
# [q, r, s, t]], ## [0, 1, 0, 0]],
|
|
# [[A, B, C, D, E], # horizontal doors ## [[0, 0, 0, 0, 0], # horizontal doors
|
|
# [F, G, H, I, J], ## [0, 0, 0, 0, 1],
|
|
# [K, L, M, N, O], ## [0, 1, 1, 1, 0],
|
|
# [P, Q, R, S, T]]] ## [0, 1, 0, 1, 1]]]
|
|
# ##
|
|
# ==>> ## ==>>
|
|
# X 0 1 2 3 4 ## X 0 1 2 3 4
|
|
# Y ┌───┬───┬───┬───┬───┐ ## Y ┌───┬───┬───┬───┬───┐
|
|
# 0 │ ∙ a ∙ b ∙ c ∙ d ∙ │ ## 0 │ ∙ │ ∙ │ ∙ │ ∙ │ ∙ │
|
|
# ├─A─┼─B─┼─C─┼─D─┼─E─┤ ## │ │ │ │ │ │
|
|
# 1 │ ∙ e ∙ f ∙ g ∙ h ∙ │ ## 1 │ ∙ │ ∙ ∙ │ ∙ ∙ │
|
|
# ├─F─┼─G─┼─H─┼─I─┼─J─┤ ## │ │ │ │ ┌───┤
|
|
# 2 │ ∙ i ∙ j ∙ k ∙ l ∙ │ ## 2 │ ∙ ∙ │ ∙ ∙ │ ∙ │
|
|
# ├─K─┼─L─┼─M─┼─N─┼─O─┤ ## │ ╶───┴───────┘ │
|
|
# 3 │ ∙ m ∙ n ∙ o ∙ p ∙ │ ## 3 │ ∙ ∙ ∙ ∙ ∙ │
|
|
# ├─P─┼─Q─┼─R─┼─S─┼─T─┤ ## │ ╶───┐ ╶───────│
|
|
# 4 │ ∙ q ∙ r ∙ s ∙ t ∙ │ ## 4 │ ∙ ∙ │ ∙ ∙ ∙ │
|
|
# └───┴───┴───┴───┴───┘ ## └───────┴───────────┘
|
|
|
|
def kruskal(x, y):
|
|
global ID
|
|
ID = 0
|
|
|
|
class case:
|
|
"""Little class for union-find"""
|
|
def __init__(self,x,y):
|
|
self.x = x
|
|
self.y = y
|
|
self.is_repr = True
|
|
self.repr = None
|
|
global ID
|
|
self.ID = ID
|
|
ID += 1
|
|
|
|
def represent(self):
|
|
if self.is_repr:
|
|
return self
|
|
else:
|
|
L = [self.repr]
|
|
while not L[0].is_repr:
|
|
L[0] = L[0].repr
|
|
return L[0]
|
|
|
|
def __eq__(self,other):
|
|
return self.represent().ID == other.represent().ID
|
|
|
|
def union(self,other):
|
|
a = self.represent()
|
|
b = other.represent()
|
|
if not (a == b):
|
|
b.is_repr = False
|
|
b.repr = a
|
|
|
|
# set of doors
|
|
doors = []
|
|
# verticals doors result
|
|
verti = []
|
|
# horizontals doors result
|
|
horiz = []
|
|
# set of cases
|
|
cases = []
|
|
## initialize vertical doors
|
|
for j in range(y):
|
|
l = []
|
|
for i in range(x-1):
|
|
l.append(1)
|
|
doors.append([i,j,'v'])
|
|
verti.append(l)
|
|
## initialize horizontal doors
|
|
for j in range(y-1):
|
|
l = []
|
|
for i in range(x):
|
|
l.append(1)
|
|
doors.append([i,j,'h'])
|
|
horiz.append(l)
|
|
|
|
## initialize cases
|
|
for i in range(y):
|
|
l = []
|
|
for j in range(x):
|
|
l.append(case(x,y))
|
|
cases.append(l)
|
|
|
|
cpt = x*y -1 # nb of openings in perfect maze
|
|
while cpt > 0:
|
|
# I choose a door
|
|
idoor = randrange(len(doors))
|
|
dx, dy, dd = doors[idoor]
|
|
cx1, cy1 = dx, dy
|
|
if dd == 'h' : cx2, cy2 = cx1, cy1+1
|
|
else : cx2, cy2 = cx1+1, cy1
|
|
|
|
C1 = cases[cy1][cx1]
|
|
C2 = cases[cy2][cx2]
|
|
# if the 2 cases separate by my door are not in same set
|
|
if not C1 == C2:
|
|
C1.union(C2)
|
|
cpt -= 1
|
|
# i modify my result
|
|
if dd == "v": verti[dy][dx] = 0
|
|
else: horiz[dy][dx] = 0
|
|
# i delete the door
|
|
del doors[idoor]
|
|
|
|
return verti,horiz
|
|
|
|
def recursive_backtrack(x, y):
|
|
# Initialisation of my variables
|
|
labyrinthe = []
|
|
for i in range(y): labyrinthe.append([0] * x)
|
|
horiz = []
|
|
for i in range(y-1): horiz.append([1] * x)
|
|
verti = []
|
|
for i in range(y): verti.append([1] * (x-1))
|
|
|
|
# I choose a random start
|
|
X_pos = randrange(x)
|
|
Y_pos = randrange(y)
|
|
labyrinthe[Y_pos][X_pos] = 1
|
|
historique = [[X_pos,Y_pos]]
|
|
|
|
# I explore a tree with deep parcours
|
|
while len(historique) != 0:
|
|
X = historique[-1][0]
|
|
Y = historique[-1][1]
|
|
|
|
possibilite = []
|
|
if (Y-1 >= 0) and (labyrinthe[Y-1][X] == 0): possibilite.append(0)
|
|
if (X+1 < x) and (labyrinthe[Y][X+1] == 0): possibilite.append(1)
|
|
if (Y+1 < y) and (labyrinthe[Y+1][X] == 0): possibilite.append(2)
|
|
if (X-1 >= 0) and (labyrinthe[Y][X-1] == 0): possibilite.append(3)
|
|
|
|
if len(possibilite) == 0:
|
|
del historique[-1]
|
|
else:
|
|
d = choice(possibilite)
|
|
if d == 0:
|
|
X1,Y1 = X, Y-1
|
|
horiz[Y-1][X] = 0
|
|
if d == 1:
|
|
X1,Y1 = X+1, Y
|
|
verti[Y][X] = 0
|
|
if d == 2:
|
|
X1,Y1 = X, Y+1
|
|
horiz[Y][X] = 0
|
|
if d == 3:
|
|
X1,Y1 = X-1, Y
|
|
verti[Y][X-1] = 0
|
|
labyrinthe[Y1][X1] = 1
|
|
historique.append([X1,Y1])
|
|
|
|
return verti, horiz
|
|
|
|
|
|
def recursive_chamber(x, y):
|
|
# Initialisation of my variables
|
|
def recursive_chamber_recu(VERTI,HORIZ,xA,yA,xB,yB):
|
|
if (xB - xA <= 1):
|
|
return
|
|
elif (yB - yA <= 1):
|
|
return
|
|
else :
|
|
dx = xB-xA
|
|
dy = yB-yA
|
|
v = randrange(0,dx+dy)
|
|
if v < dx :
|
|
x = randrange(xA,xB-1)
|
|
y = randrange(yA,yB)
|
|
for i in range(yA,yB):
|
|
if i != y:
|
|
VERTI[i][x] = 1
|
|
recursive_chamber_recu(VERTI,HORIZ,xA,yA,x+1,yB)
|
|
recursive_chamber_recu(VERTI,HORIZ,x+1,yA,xB,yB)
|
|
else:
|
|
x = randrange(xA,xB)
|
|
y = randrange(yA,yB-1)
|
|
for i in range(xA,xB):
|
|
if i != x:
|
|
HORIZ[y][i] = 1
|
|
recursive_chamber_recu(VERTI,HORIZ,xA,yA,xB,y+1)
|
|
recursive_chamber_recu(VERTI,HORIZ,xA,y+1,xB,yB)
|
|
|
|
|
|
horiz = []
|
|
for i in range(y-1): horiz.append([0] * x)
|
|
verti = []
|
|
for i in range(y): verti.append([0] * (x-1))
|
|
|
|
# appel recursif
|
|
recursive_chamber_recu(verti,horiz,0,0,x,y)
|
|
|
|
return verti, horiz
|
|
|
|
# a empty maze
|
|
def empty(x, y):
|
|
verti = []
|
|
for i in range(y):
|
|
verti.append([0] * (x-1))
|
|
|
|
horiz = []
|
|
for i in range(y-1):
|
|
horiz.append([0] * x)
|
|
return verti, horiz
|
|
|
|
# a full maze
|
|
def full(x, y):
|
|
verti = []
|
|
for i in range(y):
|
|
verti.append([1] * (x-1))
|
|
|
|
horiz = []
|
|
for i in range(y-1):
|
|
horiz.append([1] * x)
|
|
return verti, horiz
|
|
|
|
|
|
|
|
class MazeLib:
|
|
"""This Class define a Maze object"""
|
|
def __init__(self, X=5, Y=5, algorithm="empty"):
|
|
"""Use : m = Maze(X:int,Y:int, algorithm:string)"""
|
|
self.X = X # width
|
|
self.Y = Y # height
|
|
self.verti = [] # table of vertical doors
|
|
self.horiz = [] # table of horizontal doors
|
|
algorithm = algorithm.lower()
|
|
|
|
if algorithm in ("kruskal","k") :
|
|
self.verti, self.horiz = kruskal(self.X,self.Y)
|
|
self.doors = self.nbDoors()
|
|
self.algorithm = "kruskal"
|
|
self.perfect = True
|
|
|
|
elif algorithm in ("recursive_backtrack","rb") :
|
|
self.verti, self.horiz = recursive_backtrack(self.X,self.Y)
|
|
self.doors = self.nbDoors()
|
|
self.algorithm = "recursive_backtrack"
|
|
self.perfect = True
|
|
|
|
elif algorithm in ("empty","e") :
|
|
self.verti, self.horiz = empty(self.X,self.Y)
|
|
self.doors = self.nbDoors()
|
|
self.algorithm = "empty"
|
|
self.perfect = False
|
|
|
|
elif algorithm in ("full","f") :
|
|
self.verti, self.horiz = full(self.X,self.Y)
|
|
self.doors = self.nbDoors()
|
|
self.algorithm = "full"
|
|
self.perfect = False
|
|
|
|
elif algorithm in ("recursive_chamber","rc") :
|
|
self.verti, self.horiz = recursive_chamber(self.X,self.Y)
|
|
self.doors = self.nbDoors()
|
|
self.algorithm = "recursive_chamber"
|
|
self.perfect = False
|
|
|
|
else :
|
|
raise("Algorithm not recognized. Algorithm must be in ['kruskal','recursive_backtrack','empty','full']")
|
|
|
|
def __str__(self):
|
|
"""Return information about maze"""
|
|
s = "Size of maze : {}*{}\nGenerate by : {}\nNb of doors : {}\nPerfect : {}"
|
|
s = s.format(self.X,self.Y,self.algorithm,self.doors,self.perfect)
|
|
return s
|
|
|
|
def nbDoors(self):
|
|
"""Return number of doors in my maze. If maze is perfect, it equals to (self.X-1)*(self.Y-1)"""
|
|
S = 0
|
|
for k in self.verti: S += sum(k)
|
|
for k in self.horiz: S += sum(k)
|
|
return S
|
|
|
|
def verticalDoors(self):
|
|
"""Iterate on vertical doors"""
|
|
for i in range(len(self.verti)):
|
|
for j in range(len(self.verti[i])):
|
|
yield i,j, bool(self.verti[i][j])
|
|
|
|
def horizontalDoors(self):
|
|
"""Iterate on horizontal doors"""
|
|
for i in range(len(self.horiz)):
|
|
for j in range(len(self.horiz[i])):
|
|
yield i,j, bool(self.horiz[i][j])
|
|
|
|
def canMove(self, x, y, direction) :
|
|
"""return if i can move in a direction since (x,y) """
|
|
if direction in ["down","d",0] : # down
|
|
if y == self.Y-1 :return False
|
|
return not self.horiz[y][x]
|
|
if direction in ["up","u",2] : # up
|
|
if y == 0 : return False
|
|
return not self.horiz[y-1][x]
|
|
if direction in ["left","l",3] : # left
|
|
if x == 0 : return False
|
|
return not self.verti[y][x-1]
|
|
if direction in ["right","r",1] : # right
|
|
if x == self.X-1 : return False
|
|
return not self.verti[y][x]
|
|
return False
|
|
|
|
def move(self, x, y, direction) :
|
|
"""return new cord after one move in direction"""
|
|
if direction in ["down","d",0] : # down
|
|
return x,y+1
|
|
if direction in ["up","u",2] : # up
|
|
return x,y-1
|
|
if direction in ["left","l",3] : # left
|
|
return x-1,y
|
|
if direction in ["right","r",1] : # right
|
|
return x+1,y
|
|
return x,y
|
|
|
|
def liberty(self, x, y):
|
|
"""return all cases accessible from (x,y)"""
|
|
r = []
|
|
for d in ["down","up","left","right"]:
|
|
if self.canMove(x,y,d):
|
|
r.append(d)
|
|
return d
|
|
|
|
def toSquare(self):
|
|
"""return another representation of maze, a List of List of case in {0,1} """
|
|
RET = []
|
|
for i in range(self.Y*2+1):
|
|
l = []
|
|
for j in range(self.X*2+1):
|
|
if i == 0 or i == self.Y*2 or j == 0 or j == self.X*2 :
|
|
l.append(1)
|
|
else :
|
|
if (i%2==0 and j%2==0) :
|
|
l.append(1)
|
|
elif (i%2==1 and j%2==1):
|
|
l.append(0)
|
|
elif (i%2==0 and j%2==1):
|
|
l.append(self.horiz[(i-1)//2][(j-1)//2])
|
|
elif (i%2==1 and j%2==0):
|
|
l.append(self.verti[(i-1)//2][(j-1)//2])
|
|
RET.append(l)
|
|
return RET
|
|
|
|
def solve(self, xa, ya, xb, yb):
|
|
"""return a list of direction for link (xa,ya) -> (xb,yb). Null"""
|
|
Sol = []
|
|
Pile = [(xa,ya)]
|
|
laby = []
|
|
for i in range(self.Y):
|
|
laby.append(['new'] * self.X)
|
|
|
|
while len(Pile) != 0 and Pile[-1] != (xb,yb):
|
|
pos = Pile[-1]
|
|
x,y = pos[0],pos[1]
|
|
if laby[y][x] == 'new':
|
|
possibilite = []
|
|
for d in ['down',"left","up","right"]:
|
|
if self.canMove(pos[0],pos[1],d) :
|
|
nx,ny = self.move(pos[0],pos[1],d)
|
|
if laby[ny][nx] == 'new' :
|
|
possibilite.append(d)
|
|
|
|
laby[y][x] = possibilite
|
|
elif laby[y][x] == "old":
|
|
del Pile[-1]
|
|
if len(Sol) != 0:
|
|
del Sol[-1]
|
|
elif type(laby[y][x]) == list:
|
|
if len(laby[y][x]) == 0:
|
|
laby[y][x] = "old"
|
|
else:
|
|
ichoix = -1#randrange(len(laby[y][x]))
|
|
choix = laby[y][x][ichoix]
|
|
Pile.append(self.move(x,y,choix))
|
|
Sol.append(choix)
|
|
del laby[y][x][ichoix]
|
|
|
|
return Sol
|
|
|
|
def furthestBox(self, xa, ya):
|
|
"""return the case furtest of the case (xa,ya)"""
|
|
Sol = []
|
|
dmax = len(Sol)
|
|
pmax = Sol.copy()
|
|
cmax = (xa,ya)
|
|
|
|
Pile = [(xa,ya)]
|
|
laby = []
|
|
for i in range(self.Y):
|
|
laby.append(['new'] * self.X)
|
|
|
|
while len(Pile) != 0:
|
|
pos = Pile[-1]
|
|
x,y = pos[0],pos[1]
|
|
if laby[y][x] == 'new':
|
|
possibilite = []
|
|
for d in ['down',"left","up","right"]:
|
|
if self.canMove(pos[0],pos[1],d) :
|
|
nx,ny = self.move(pos[0],pos[1],d)
|
|
if laby[ny][nx] == 'new' :
|
|
possibilite.append(d)
|
|
|
|
laby[y][x] = possibilite
|
|
elif laby[y][x] == "old":
|
|
if len(Sol) > dmax:
|
|
dmax = len(Sol)
|
|
pmax = Sol.copy()
|
|
cmax = (x,y)
|
|
del Pile[-1]
|
|
if len(Sol) != 0:
|
|
del Sol[-1]
|
|
elif type(laby[y][x]) == list:
|
|
if len(laby[y][x]) == 0:
|
|
laby[y][x] = "old"
|
|
else:
|
|
ichoix = -1#randrange(len(laby[y][x]))
|
|
choix = laby[y][x][ichoix]
|
|
Pile.append(self.move(x,y,choix))
|
|
Sol.append(choix)
|
|
del laby[y][x][ichoix]
|
|
|
|
return pmax, cmax
|
|
|
|
def longestWay(self):
|
|
Xa = randrange(self.X)
|
|
Ya = randrange(self.Y)
|
|
p,B = self.furthestBox(Xa,Ya)
|
|
path,C = self.furthestBox(B[0],B[1])
|
|
return B,path,C
|
|
|
|
|
|
|
|
|
|
def save(self):
|
|
"""Return a string contain's all information. it can be save in file, print, etc.."""
|
|
s = "{};{};{};{};{};{};{}".format(self.X, self.Y, self.doors, self.algorithm, self.perfect, self.verti, self.horiz)
|
|
return s
|
|
|
|
def load(self, st):
|
|
"""Load a Maze since a string of format save"""
|
|
cont = st.split(";")
|
|
self.X = int(cont[0])
|
|
self.Y = int(cont[1])
|
|
self.doors = int(cont[2])
|
|
self.algorithm = cont[3]
|
|
self.perfect = bool(cont[4])
|
|
self.verti = cont[5].split("], [")
|
|
for i in range(len(self.verti)):
|
|
self.verti[i] = self.verti[i].split(',')
|
|
for j in range(len(self.verti[i])):
|
|
self.verti[i][j] = self.verti[i][j].replace("[","")
|
|
self.verti[i][j] = self.verti[i][j].replace("]","")
|
|
self.verti[i][j] = self.verti[i][j].replace(" ","")
|
|
self.verti[i][j] = int(self.verti[i][j])
|
|
|
|
self.horiz = cont[6].split("], [")
|
|
for i in range(len(self.horiz)):
|
|
self.horiz[i] = self.horiz[i].split(',')
|
|
for j in range(len(self.horiz[i])):
|
|
self.horiz[i][j] = self.horiz[i][j].replace("[","")
|
|
self.horiz[i][j] = self.horiz[i][j].replace("]","")
|
|
self.horiz[i][j] = self.horiz[i][j].replace(" ","")
|
|
self.horiz[i][j] = int(self.horiz[i][j])
|
|
|
|
def toTxt(self, centre=False, coord=False, basic= False):
|
|
"""return a txt representation of maze in ASCII art"""
|
|
if type(centre) == bool:
|
|
if centre : centre = "*"
|
|
else : centre = " "
|
|
else:
|
|
centre = centre[0]
|
|
|
|
if basic :
|
|
if coord:
|
|
R = " X"
|
|
for i in range(self.X):
|
|
R += " {} ".format(i%10)
|
|
R += "\n"
|
|
R += "Y +"
|
|
r = "0 |"
|
|
else:
|
|
R = "+"
|
|
r = "|"
|
|
for j in range(self.X-1):
|
|
if self.verti[0][j]:
|
|
R += "---+"
|
|
r += " {} |".format(centre)
|
|
else:
|
|
R += "----"
|
|
r += " {} ".format(centre)
|
|
R += "---+\n"
|
|
r += " {} |\n".format(centre)
|
|
R += r
|
|
for i in range(self.Y-1):
|
|
if coord:
|
|
if self.horiz[i][0]:
|
|
l1 = " +"
|
|
else:
|
|
l1 = " |"
|
|
l2 = "{} |".format((i+1)%10)
|
|
else:
|
|
if self.horiz[i][0]:
|
|
l1 = "+"
|
|
else:
|
|
l1 = "|"
|
|
l2 = "|"
|
|
for j in range(self.X-1):
|
|
inter = "+"
|
|
if self.horiz[i][j] and self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = "-"
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and self.verti[i][j] and self.verti[i+1][j] : inter = "|"
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = " "
|
|
|
|
if self.horiz[i][j]:
|
|
l1 += "---"+inter
|
|
else:
|
|
l1 += " "+inter
|
|
|
|
if self.verti[i+1][j]:
|
|
l2 += " {} |".format(centre)
|
|
else:
|
|
l2 += " {} ".format(centre)
|
|
if self.horiz[i][-1]:
|
|
l1 += "---+"
|
|
else:
|
|
l1 += " |"
|
|
l2 += " {} |".format(centre)
|
|
|
|
R += l1 + "\n"
|
|
R += l2 + "\n"
|
|
if coord:
|
|
r = " +"
|
|
else:
|
|
r = "+"
|
|
for j in range(self.X-1):
|
|
if self.verti[-1][j]:
|
|
r += "---+"
|
|
else:
|
|
r += "----"
|
|
r += "---+"
|
|
R += r
|
|
return R
|
|
|
|
else :
|
|
if coord:
|
|
R = " X"
|
|
for i in range(self.X):
|
|
R += " {} ".format(i%10)
|
|
R += "\n"
|
|
R += "Y ┌"
|
|
r = "0 │"
|
|
else:
|
|
R = "┌"
|
|
r = "│"
|
|
for j in range(self.X-1):
|
|
if self.verti[0][j]:
|
|
R += "───┬"
|
|
r += " {} │".format(centre)
|
|
else:
|
|
R += "────"
|
|
r += " {} ".format(centre)
|
|
R += "───┐\n"
|
|
r += " {} │\n".format(centre)
|
|
R += r
|
|
for i in range(self.Y-1):
|
|
if coord:
|
|
if self.horiz[i][0]:
|
|
l1 = " ├"
|
|
else:
|
|
l1 = " │"
|
|
l2 = "{} │".format((i+1)%10)
|
|
else:
|
|
if self.horiz[i][0]:
|
|
l1 = "├"
|
|
else:
|
|
l1 = "│"
|
|
l2 = "│"
|
|
for j in range(self.X-1):
|
|
# 4 door
|
|
if self.horiz[i][j] and self.horiz[i][j+1] and self.verti[i][j] and self.verti[i+1][j] : inter = "┼"
|
|
# 3 door
|
|
if self.horiz[i][j] and self.horiz[i][j+1] and self.verti[i][j] and not self.verti[i+1][j] : inter = "┴"
|
|
if self.horiz[i][j] and self.horiz[i][j+1] and not self.verti[i][j] and self.verti[i+1][j] : inter = "┬"
|
|
if self.horiz[i][j] and not self.horiz[i][j+1] and self.verti[i][j] and self.verti[i+1][j] : inter = "┤"
|
|
if not self.horiz[i][j] and self.horiz[i][j+1] and self.verti[i][j] and self.verti[i+1][j] : inter = "├"
|
|
# 2 door
|
|
if self.horiz[i][j] and self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = "─"
|
|
if self.horiz[i][j] and not self.horiz[i][j+1] and self.verti[i][j] and not self.verti[i+1][j] : inter = "┘"
|
|
if not self.horiz[i][j] and self.horiz[i][j+1] and self.verti[i][j] and not self.verti[i+1][j] : inter = "└"
|
|
if self.horiz[i][j] and not self.horiz[i][j+1] and not self.verti[i][j] and self.verti[i+1][j] : inter = "┐"
|
|
if not self.horiz[i][j] and self.horiz[i][j+1] and not self.verti[i][j] and self.verti[i+1][j] : inter = "┌"
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and self.verti[i][j] and self.verti[i+1][j] : inter = "│"
|
|
# 1 door
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and not self.verti[i][j] and self.verti[i+1][j] : inter = "╷"
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and self.verti[i][j] and not self.verti[i+1][j] : inter = "╵"
|
|
if not self.horiz[i][j] and self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = "╶"
|
|
if self.horiz[i][j] and not self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = "╴"
|
|
# 0 door
|
|
if not self.horiz[i][j] and not self.horiz[i][j+1] and not self.verti[i][j] and not self.verti[i+1][j] : inter = " "
|
|
if self.horiz[i][j]:
|
|
l1 += "───"+inter
|
|
else:
|
|
l1 += " "+inter
|
|
|
|
if self.verti[i+1][j]:
|
|
l2 += " {} │".format(centre)
|
|
else:
|
|
l2 += " {} ".format(centre)
|
|
if self.horiz[i][-1]:
|
|
l1 += "───┤"
|
|
else:
|
|
l1 += " │"
|
|
l2 += " {} │".format(centre)
|
|
|
|
R += l1 + "\n"
|
|
R += l2 + "\n"
|
|
if coord:
|
|
r = " └"
|
|
else:
|
|
r = "└"
|
|
for j in range(self.X-1):
|
|
if self.verti[-1][j]:
|
|
r += "───┴"
|
|
else:
|
|
r += "────"
|
|
r += "───┘"
|
|
R += r
|
|
return R |