home · contact · privacy
Use self.max_map_awakeness to recude magic numbering.
[plomrogue2-experiments] / new / plomrogue / things.py
1 from plomrogue.errors import GameError
2 from plomrogue.mapping import YX, Map, FovMapHex
3
4
5
6 class ThingBase:
7     type_ = '?'
8
9     def __init__(self, game, id_=None, position=(YX(0,0), YX(0,0))):
10         self.game = game
11         if id_ is None:
12             self.id_ = self.game.new_thing_id()
13         else:
14             self.id_ = id_
15         self.position = position
16
17     @property
18     def position(self):
19         return self._position
20
21     def _position_set(self, pos):
22         """Set self._position to pos.
23
24         We use this setter as core to the @position.setter property
25         method due to property setter subclassing not yet working
26         properly, see <https://bugs.python.org/issue14965>. We will
27         therefore super() _position_set instead of @position.setter in
28         subclasses.
29
30         """
31         self._position = pos
32
33     @position.setter
34     def position(self, pos):
35         self._position_set(pos)
36
37
38
39 class Thing(ThingBase):
40     blocking = False
41     in_inventory = False
42
43     def __init__(self, *args, **kwargs):
44         self.inventory = []
45         self._radius = 8
46         super().__init__(*args, **kwargs)
47
48     def proceed(self):
49         pass
50
51     def _position_set(self, pos):
52         super()._position_set(pos)
53         for t_id in self.inventory:
54             t = self.game.get_thing(t_id)
55             t.position = self.position
56         if not self.id_ == self.game.player_id:
57             return
58         edge_left = self.position[1].x - self._radius
59         edge_right = self.position[1].x + self._radius
60         edge_up = self.position[1].y - self._radius
61         edge_down = self.position[1].y + self._radius
62         if edge_left < 0:
63             self.game.get_map(self.position[0] + YX(1,-1))
64             self.game.get_map(self.position[0] + YX(0,-1))
65             self.game.get_map(self.position[0] + YX(-1,-1))
66         if edge_right >= self.game.map_size.x:
67             self.game.get_map(self.position[0] + YX(1,1))
68             self.game.get_map(self.position[0] + YX(0,1))
69             self.game.get_map(self.position[0] + YX(-1,1))
70         if edge_up < 0:
71             self.game.get_map(self.position[0] + YX(-1,1))
72             self.game.get_map(self.position[0] + YX(-1,0))
73             self.game.get_map(self.position[0] + YX(-1,-1))
74         if edge_down >= self.game.map_size.y:
75             self.game.get_map(self.position[0] + YX(1,1))
76             self.game.get_map(self.position[0] + YX(1,0))
77             self.game.get_map(self.position[0] + YX(1,-1))
78         #alternative
79         #if self.position[1].x < self._radius:
80         #    self.game.get_map(self.position[0] - YX(0,1))
81         #if self.position[1].y < self._radius:
82         #    self.game.get_map(self.position[0] - YX(1,0))
83         #if self.position[1].x > self.game.map_size.x - self._radius:
84         #    self.game.get_map(self.position[0] + YX(0,1))
85         #if self.position[1].y > self.game.map_size.y - self._radius:
86         #    self.game.get_map(self.position[0] + YX(1,0))
87         #if self.position[1].y < self._radius and \
88         #   self.position[1].x <= [pos for pos in
89         #                          diagonal_distance_edge
90         #                          if pos.y == self.position[1].y][0].x:
91         #    self.game.get_map(self.position[0] - YX(1,1))
92
93
94
95 class ThingItem(Thing):
96     pass
97
98
99
100 class ThingFood(ThingItem):
101     type_ = 'food'
102
103
104
105 class ThingAnimate(Thing):
106     blocking = True
107
108     def __init__(self, *args, **kwargs):
109         super().__init__(*args, **kwargs)
110         self.set_task('WAIT')
111         self._last_task_result = None
112         self.unset_surroundings()
113         self.close_maps = ()
114
115     def _position_set(self, pos):
116         """For player we need to update .close_maps on every move via the
117            self.surroundings property method, to keep their reality
118            bubble in sync with their movement.
119
120         """
121         super()._position_set(pos)
122         if self.id_ == self.game.player_id:
123             if not hasattr(self, '_surroundings'):
124                 self._surroundings = None
125             self.surroundings
126
127     def move_on_dijkstra_map(self, own_pos, targets):
128         visible_map = self.get_visible_map()
129         dijkstra_map = Map(visible_map.size,
130                            start_indented=visible_map.start_indented)
131         n_max = 256
132         dijkstra_map.terrain = [n_max for i in range(dijkstra_map.size_i)]
133         for target in targets:
134             dijkstra_map[target] = 0
135         shrunk = True
136         get_neighbors = self.game.map_geometry.get_neighbors
137         while shrunk:
138             shrunk = False
139             for pos in dijkstra_map:
140                 if visible_map[pos] != '.':
141                     continue
142                 neighbors = get_neighbors((YX(0,0), pos), dijkstra_map.size,
143                                           dijkstra_map.start_indented)
144                 for direction in neighbors:
145                     big_yx, small_yx = neighbors[direction]
146                     if big_yx == YX(0,0) and \
147                        dijkstra_map[small_yx] < dijkstra_map[pos] - 1:
148                         dijkstra_map[pos] = dijkstra_map[small_yx] + 1
149                         shrunk = True
150         #print('DEBUG DIJKSTRA ---------------------', self.id_, self.position)
151         #for y, line in dijkstra_map.lines():
152         #    line_to_print = []
153         #    for x in line:
154         #        line_to_print += ['%3s' % x]
155         #    print(' '.join(line_to_print))
156         neighbors = get_neighbors((YX(0,0), own_pos), dijkstra_map.size,
157                                   dijkstra_map.start_indented)
158         n = n_max
159         target_direction = None
160         for direction in sorted(neighbors.keys()):
161             big_yx, small_yx = neighbors[direction]
162             if big_yx == (0,0):
163                 n_new = dijkstra_map[small_yx]
164                 if n_new < n:
165                     n = n_new
166                     target_direction = direction
167         return target_direction
168
169     #def hunt_player(self):
170     #    visible_things = self.get_visible_things()
171     #    target = None
172     #    for t in visible_things:
173     #        if t.type_ == 'human':
174     #            target = t.position[1] - self.view_offset
175     #            break
176     #    if target is not None:
177     #        try:
178     #            offset_self_pos = self.position[1] - self.view_offset
179     #            target_dir = self.move_on_dijkstra_map(offset_self_pos,
180     #                                                   [target])
181     #            if target_dir is not None:
182     #                self.set_task('MOVE', (target_dir,))
183     #                return True
184     #        except GameError:
185     #            pass
186     #    return False
187
188     def hunt_food_satisfaction(self):
189         for id_ in self.inventory:
190             t = self.game.get_thing(id_)
191             if t.type_ == 'food':
192                 self.set_task('EAT', (id_,))
193                 return True
194         for id_ in self.get_pickable_items():
195             t = self.game.get_thing(id_)
196             if t.type_ == 'food':
197                 self.set_task('PICKUP', (id_,))
198                 return True
199         visible_things = self.get_visible_things()
200         food_targets = []
201         for t in visible_things:
202             if t.type_ == 'food':
203                 food_targets += [self.game.map_geometry.pos_in_view(t.position,
204                                                                     self.view_offset,
205                                                                     self.game.map_size)]
206         offset_self_pos = self.game.map_geometry.pos_in_view(self.position,
207                                                              self.view_offset,
208                                                              self.game.map_size)
209         target_dir = self.move_on_dijkstra_map(offset_self_pos,
210                                                food_targets)
211         if target_dir:
212             try:
213                 self.set_task('MOVE', (target_dir,))
214                 return True
215             except GameError:
216                 pass
217         return False
218
219     def decide_task(self):
220         #if not self.hunt_player():
221         if not self.hunt_food_satisfaction():
222             self.set_task('WAIT')
223
224     def set_task(self, task_name, args=()):
225         task_class = self.game.tasks[task_name]
226         self.task = task_class(self, args)
227         self.task.check()  # will throw GameError if necessary
228
229     def proceed(self, is_AI=True):
230         """Further the thing in its tasks, decrease its health.
231
232         First, ensures an empty map, decrements .health and kills
233         thing if crossing zero (removes from self.game.things for AI
234         thing, or unsets self.game.player_is_alive for player thing);
235         then checks that self.task is still possible and aborts if
236         otherwise (for AI things, decides a new task).
237
238         Then decrements .task.todo; if it thus falls to <= 0, enacts
239         method whose name is 'task_' + self.task.name and sets .task =
240         None. If is_AI, calls .decide_task to decide a self.task.
241
242         """
243         self.unset_surroundings()
244         self.health -= 1
245         if self.health <= 0:
246             if self is self.game.player:
247                 self.game.player_is_alive = False
248             else:
249                 del self.game.things[self.game.things.index(self)]
250             return
251         try:
252             self.task.check()
253         except GameError as e:
254             self.task = None
255             self._last_task_result = e
256             if is_AI:
257                 try:
258                     self.decide_task()
259                 except GameError:
260                     self.set_task('WAIT')
261             return
262         self.task.todo -= 1
263         if self.task.todo <= 0:
264             self._last_task_result = self.task.do()
265             self.task = None
266         if is_AI and self.task is None:
267             try:
268                 self.decide_task()
269             except GameError:
270                 self.set_task('WAIT')
271
272     def unset_surroundings(self):
273         self._stencil = None
274         self._surroundings = None
275
276     @property
277     def view_offset(self):
278         return self.game.map_geometry.get_view_offset(self.game.map_size,
279                                                       self.position,
280                                                       self._radius)
281
282     @property
283     def surroundings(self):
284         if self._surroundings is not None:
285             return self._surroundings
286         s, close_maps = self.\
287             game.map_geometry.get_view_and_seen_maps(self.game.map_size,
288                                                      self.game.get_map,
289                                                      self._radius,
290                                                      self.view_offset)
291         self.close_maps = close_maps
292         self._surroundings = s
293         return self._surroundings
294
295     def get_stencil(self):
296         if self._stencil is not None:
297             return self._stencil
298         m = Map(self.surroundings.size, ' ', self.surroundings.start_indented)
299         for pos in self.surroundings:
300             if self.surroundings[pos] in {'.', '~'}:
301                 m[pos] = '.'
302         fov_center = YX((m.size.y) // 2, m.size.x // 2)
303         self._stencil = FovMapHex(m, fov_center)
304         return self._stencil
305
306     def get_visible_map(self):
307         stencil = self.get_stencil()
308         m = Map(self.surroundings.size, ' ', self.surroundings.start_indented)
309         for pos in m:
310             if stencil[pos] == '.':
311                 m[pos] = self.surroundings[pos]
312         return m
313
314     def get_visible_things(self):
315         stencil = self.get_stencil()
316         visible_things = []
317         for thing in self.game.things:
318             pos = self.game.map_geometry.pos_in_view(thing.position,
319                                                      self.view_offset,
320                                                      self.game.map_size)
321             if pos.y < 0 or pos.x < 0 or\
322                pos.y >= stencil.size.y or pos.x >= stencil.size.x:
323                 continue
324             if (not thing.in_inventory) and stencil[pos] == '.':
325                 visible_things += [thing]
326         return visible_things
327
328     def get_pickable_items(self):
329         pickable_ids = []
330         visible_things = self.get_visible_things()
331         neighbor_fields = self.game.map_geometry.get_neighbors(self.position,
332                                                                self.game.map_size)
333         for t in [t for t in visible_things
334                   if isinstance(t, ThingItem) and
335                   (t.position == self.position or
336                    t.position in neighbor_fields.values())]:
337             pickable_ids += [t.id_]
338         return pickable_ids
339
340
341
342 class ThingHuman(ThingAnimate):
343     type_ = 'human'
344     health = 100
345
346
347
348 class ThingMonster(ThingAnimate):
349     type_ = 'monster'
350     health = 50