home · contact · privacy
Make AI logic clearer in code.
[plomrogue2-experiments] / new / plomrogue / mapping.py
1 from plomrogue.errors import ArgError
2
3
4
5 class Map:
6
7     def __init__(self, size=(0, 0)):
8         self.size = size
9         self.terrain = '?'*self.size_i
10
11     def __getitem__(self, yx):
12         return self.terrain[self.get_position_index(yx)]
13
14     def __setitem__(self, yx, c):
15         pos_i = self.get_position_index(yx)
16         if type(c) == str:
17             self.terrain = self.terrain[:pos_i] + c + self.terrain[pos_i + 1:]
18         else:
19             self.terrain[pos_i] = c
20
21     def __iter__(self):
22         """Iterate over YX position coordinates."""
23         for y in range(self.size[0]):
24             for x in range(self.size[1]):
25                 yield (y, x)
26
27     @property
28     def size_i(self):
29         return self.size[0] * self.size[1]
30
31     def set_line(self, y, line):
32         height_map = self.size[0]
33         width_map = self.size[1]
34         if y >= height_map:
35             raise ArgError('too large row number %s' % y)
36         width_line = len(line)
37         if width_line > width_map:
38             raise ArgError('too large map line width %s' % width_line)
39         self.terrain = self.terrain[:y * width_map] + line +\
40                        self.terrain[(y + 1) * width_map:]
41
42     def get_position_index(self, yx):
43         return yx[0] * self.size[1] + yx[1]
44
45     def lines(self):
46         width = self.size[1]
47         for y in range(self.size[0]):
48             yield (y, self.terrain[y * width:(y + 1) * width])
49
50     def get_fov_map(self, yx):
51         return self.fov_map_type(self, yx)
52
53     def get_directions(self):
54         directions = []
55         for name in dir(self):
56             if name[:5] == 'move_':
57                 directions += [name[5:]]
58         return directions
59
60     def get_neighbors(self, pos):
61         neighbors = {}
62         pos = tuple(pos)
63         if not hasattr(self, 'neighbors_to'):
64             self.neighbors_to = {}
65         if pos in self.neighbors_to:
66             return self.neighbors_to[pos]
67         for direction in self.get_directions():
68             neighbors[direction] = None
69             neighbor_pos = self.move(pos, direction)
70             if neighbor_pos:
71                 neighbors[direction] = neighbor_pos
72         self.neighbors_to[pos] = neighbors
73         return neighbors
74
75     def new_from_shape(self, init_char):
76         import copy
77         new_map = copy.deepcopy(self)
78         for pos in new_map:
79             new_map[pos] = init_char
80         return new_map
81
82     def move(self, start_pos, direction):
83         mover = getattr(self, 'move_' + direction)
84         new_pos = mover(start_pos)
85         if new_pos[0] < 0 or new_pos[1] < 0 or \
86                 new_pos[0] >= self.size[0] or new_pos[1] >= self.size[1]:
87             return None
88         return new_pos
89
90
91
92 class MapWithLeftRightMoves(Map):
93
94     def move_LEFT(self, start_pos):
95         return (start_pos[0], start_pos[1] - 1)
96
97     def move_RIGHT(self, start_pos):
98         return (start_pos[0], start_pos[1] + 1)
99
100
101
102 class MapSquare(MapWithLeftRightMoves):
103
104     def move_UP(self, start_pos):
105         return (start_pos[0] - 1, start_pos[1])
106
107     def move_DOWN(self, start_pos):
108         return (start_pos[0] + 1, start_pos[1])
109
110
111
112 class MapHex(MapWithLeftRightMoves):
113
114     def __init__(self, *args, **kwargs):
115         super().__init__(*args, **kwargs)
116         self.fov_map_type = FovMapHex
117
118     def move_UPLEFT(self, start_pos):
119         if start_pos[0] % 2 == 1:
120             return (start_pos[0] - 1, start_pos[1] - 1)
121         else:
122             return (start_pos[0] - 1, start_pos[1])
123
124     def move_UPRIGHT(self, start_pos):
125         if start_pos[0] % 2 == 1:
126             return (start_pos[0] - 1, start_pos[1])
127         else:
128             return (start_pos[0] - 1, start_pos[1] + 1)
129
130     def move_DOWNLEFT(self, start_pos):
131         if start_pos[0] % 2 == 1:
132              return (start_pos[0] + 1, start_pos[1] - 1)
133         else:
134                return (start_pos[0] + 1, start_pos[1])
135
136     def move_DOWNRIGHT(self, start_pos):
137         if start_pos[0] % 2 == 1:
138             return (start_pos[0] + 1, start_pos[1])
139         else:
140             return (start_pos[0] + 1, start_pos[1] + 1)
141
142
143
144 class FovMap:
145
146     def __init__(self, source_map, yx):
147         self.source_map = source_map
148         self.size = self.source_map.size
149         self.terrain = '?' * self.size_i
150         self[yx] = '.'
151         self.shadow_cones = []
152         self.circle_out(yx, self.shadow_process_hex)
153
154     def shadow_process_hex(self, yx, distance_to_center, dir_i, dir_progress):
155         # Possible optimization: If no shadow_cones yet and self[yx] == '.',
156         # skip all.
157         CIRCLE = 360  # Since we'll float anyways, number is actually arbitrary.
158
159         def correct_arm(arm):
160             if arm < 0:
161                 arm += CIRCLE
162             return arm
163
164         def in_shadow_cone(new_cone):
165             for old_cone in self.shadow_cones:
166                 if old_cone[0] >= new_cone[0] and \
167                     new_cone[1] >= old_cone[1]:
168                     #print('DEBUG shadowed by:', old_cone)
169                     return True
170                 # We might want to also shade hexes whose middle arm is inside a
171                 # shadow cone for a darker FOV. Note that we then could not for
172                 # optimization purposes rely anymore on the assumption that a
173                 # shaded hex cannot add growth to existing shadow cones.
174             return False
175
176         def merge_cone(new_cone):
177             import math
178             for old_cone in self.shadow_cones:
179                 if new_cone[0] > old_cone[0] and \
180                     (new_cone[1] < old_cone[0] or
181                      math.isclose(new_cone[1], old_cone[0])):
182                     #print('DEBUG merging to', old_cone)
183                     old_cone[0] = new_cone[0]
184                     #print('DEBUG merged cone:', old_cone)
185                     return True
186                 if new_cone[1] < old_cone[1] and \
187                     (new_cone[0] > old_cone[1] or
188                      math.isclose(new_cone[0], old_cone[1])):
189                     #print('DEBUG merging to', old_cone)
190                     old_cone[1] = new_cone[1]
191                     #print('DEBUG merged cone:', old_cone)
192                     return True
193             return False
194
195         def eval_cone(cone):
196             #print('DEBUG CONE', cone, '(', step_size, distance_to_center, number_steps, ')')
197             if in_shadow_cone(cone):
198                 return
199             self[yx] = '.'
200             if self.source_map[yx] != '.':
201                 #print('DEBUG throws shadow', cone)
202                 unmerged = True
203                 while merge_cone(cone):
204                     unmerged = False
205                 if unmerged:
206                     self.shadow_cones += [cone]
207
208         #print('DEBUG', yx)
209         step_size = (CIRCLE/len(self.circle_out_directions)) / distance_to_center
210         number_steps = dir_i * distance_to_center + dir_progress
211         left_arm = correct_arm(-(step_size/2) - step_size*number_steps)
212         right_arm = correct_arm(left_arm - step_size)
213         # Optimization potential: left cone could be derived from previous
214         # right cone. Better even: Precalculate all cones.
215         if right_arm > left_arm:
216             eval_cone([left_arm, 0])
217             eval_cone([CIRCLE, right_arm])
218         else:
219             eval_cone([left_arm, right_arm])
220
221     def basic_circle_out_move(self, pos, direction):
222         """Move position pos into direction. Return whether still in map."""
223         mover = getattr(self, 'move_' + direction)
224         pos = mover(pos)
225         if pos[0] < 0 or pos[1] < 0 or \
226             pos[0] >= self.size[0] or pos[1] >= self.size[1]:
227             return pos, False
228         return pos, True
229
230     def circle_out(self, yx, f):
231         # Optimization potential: Precalculate movement positions. (How to check
232         # circle_in_map then?)
233         # Optimization potential: Precalculate what hexes are shaded by what hex
234         # and skip evaluation of already shaded hexes. (This only works if hex
235         # shading implies they completely lie in existing shades; otherwise we
236         # would lose shade growth through hexes at shade borders.)
237
238         # TODO: Start circling only in earliest obstacle distance.
239         circle_in_map = True
240         distance = 1
241         yx = yx[:]
242         #print('DEBUG CIRCLE_OUT', yx)
243         while circle_in_map:
244             circle_in_map = False
245             yx, _ = self.basic_circle_out_move(yx, 'RIGHT')
246             for dir_i in range(len(self.circle_out_directions)):
247                 for dir_progress in range(distance):
248                     direction = self.circle_out_directions[dir_i]
249                     yx, test = self.circle_out_move(yx, direction)
250                     if test:
251                         f(yx, distance, dir_i, dir_progress)
252                         circle_in_map = True
253             distance += 1
254
255
256
257 class FovMapHex(FovMap, MapHex):
258     circle_out_directions = ('DOWNLEFT', 'LEFT', 'UPLEFT',
259                              'UPRIGHT', 'RIGHT', 'DOWNRIGHT')
260
261     def circle_out_move(self, yx, direction):
262         return self.basic_circle_out_move(yx, direction)
263
264
265
266 class FovMapSquare(FovMap, MapSquare):
267     circle_out_directions = (('DOWN', 'LEFT'), ('LEFT', 'UP'),
268                              ('UP', 'RIGHT'), ('RIGHT', 'DOWN'))
269
270     def circle_out_move(self, yx, direction):
271         self.basic_circle_out_move(yx, direction[0])
272         return self.basic_circle_out_move(yx, direction[1])