-
Notifications
You must be signed in to change notification settings - Fork 0
/
level.py
96 lines (83 loc) · 3.25 KB
/
level.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
from runes import architecture
from runes import architecture
def adjacent_cells(row, col, grid):
"""Generates a list of adjacent cells, given a position and grid of cells.
Arguments:
row, col -- position of the current cell in the grid
grid -- grid of cells
"""
adjacents = {}
coordinates = ((row - 1, col, 'north'), (row - 1, col + 1, 'northeast'),
(row, col + 1, 'east'), (row + 1, col + 1, 'southeast'),
(row + 1, col, 'south'), (row + 1, col - 1, 'southwest'),
(row, col - 1, 'west'), (row - 1, col - 1, 'northwest'))
for rr, cc, dir in coordinates:
if rr < 0 or cc < 0:
adjacents[dir] = None
elif rr >= 21:
adjacents[dir] = None
elif cc >= 80:
adjacents[dir] = None
else:
adjacents[dir] = grid[rr][cc]
return adjacents
class Map():
def __init__(self, default, cells=()):
# Initialize map with default cell
self.map = [[deepcopy(default) for _ in range(80)] for _ in range(21)]
# Load pre-specified cells
for row, col, cell in cells:
self.map[row][col] = cell
# Build adjacents
for row in range(21):
for col in range(80):
self.map[row][col].adjacent = adjacent_cells(row, col, self.map)
def render(self):
rendered = [[cell.render() for cell in row] for row in self.map]
result = []
for row in rendered:
row.append('\n')
result.extend(row)
return result
def cell(self, row, column):
return self.map[row][column]
def draw_point(self, point, type='wall'):
if type == 'wall':
self.map[point[0]][point[1]].open = False
elif type == 'floor':
self.map[point[0]][point[1]].open = True
self.map[point[0]][point[1]].open = False
elif type == 'door':
self.map[point[0]][point[1]].open = False
self.map[point[0]][point[1]].door = True
def draw_line(self, start, end, type='wall'):
y0, x0 = start
y1, x1 = end
dy = y1 - y0
dx = x1 - x0
dy_sign = 1 if dy >= 0 else -1
dx_sign = 1 if dx >= 0 else -1
if dy == 0:
for x in range(x0, x1, dx_sign):
self.draw_point((y0, x), type=type)
elif dx == 0:
for y in range(y0, y1, dy_sign):
self.draw_point((y, start[1]), type=type)
else:
slope = dy / dx
if dy > dx:
xx = 0
for x in range(x0, x1 + 1, dx_sign):
for y in range(y0 + xx * slope, y1 + (xx + 1) * slope, dy_sign):
self.draw_point((y, x), type=type)
xx += 1
elif dx > dy:
yy = 0
for y in range(y0, y1 + 1, dy_sign):
for x in range(x0 + yy / slope, x1 + (yy + 1) / slope, dx_sign):
self.draw_point((y, x), type=type)
def draw_shape(self, points, closed=False, type='wall'):
for ii in range(len(points) - 1):
self.draw_line(points[ii], points[ii + 1], type=type)
if closed:
self.draw_line(points[-1], points[0], type=type)