from plomrogue.errors import GameError
+from plomrogue.mapping import YX, Map, FovMapHex
class ThingBase:
type_ = '?'
- def __init__(self, world, id_=None, position=((0,0), (0,0))):
+ def __init__(self, world, id_=None, position=(YX(0,0), YX(0,0))):
self.world = world
- self.position = position
if id_ is None:
self.id_ = self.world.new_thing_id()
else:
self.id_ = id_
+ self.position = position
+
+ @property
+ def position(self):
+ return self._position
+
+ def _position_set(self, pos):
+ """Set self._position to pos.
+
+ We use this setter as core to the @position.setter property
+ method due to property setter subclassing not yet working
+ properly, see <https://bugs.python.org/issue14965>. We will
+ therefore super() _position_set instead of @position.setter in
+ subclasses.
+
+ """
+ self._position = pos
+
+ @position.setter
+ def position(self, pos):
+ self._position_set(pos)
in_inventory = False
def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
self.inventory = []
+ self._radius = 8
+ super().__init__(*args, **kwargs)
def proceed(self):
pass
+ def _position_set(self, pos):
+ super()._position_set(pos)
+ for t_id in self.inventory:
+ t = self.world.get_thing(t_id)
+ t.position = self.position
+ if not self.id_ == self.world.player_id:
+ return
+ edge_left = self.position[1].x - self._radius
+ edge_right = self.position[1].x + self._radius
+ edge_up = self.position[1].y - self._radius
+ edge_down = self.position[1].y + self._radius
+ if edge_left < 0:
+ self.world.get_map(self.position[0] + YX(1,-1))
+ self.world.get_map(self.position[0] + YX(0,-1))
+ self.world.get_map(self.position[0] + YX(-1,-1))
+ if edge_right >= self.world.game.map_size.x:
+ self.world.get_map(self.position[0] + YX(1,1))
+ self.world.get_map(self.position[0] + YX(0,1))
+ self.world.get_map(self.position[0] + YX(-1,1))
+ if edge_up < 0:
+ self.world.get_map(self.position[0] + YX(-1,1))
+ self.world.get_map(self.position[0] + YX(-1,0))
+ self.world.get_map(self.position[0] + YX(-1,-1))
+ if edge_down >= self.world.game.map_size.y:
+ self.world.get_map(self.position[0] + YX(1,1))
+ self.world.get_map(self.position[0] + YX(1,0))
+ self.world.get_map(self.position[0] + YX(1,-1))
+
class ThingItem(Thing):
super().__init__(*args, **kwargs)
self.set_task('WAIT')
self._last_task_result = None
- self._radius = 16
self.unset_surroundings()
def move_on_dijkstra_map(self, own_pos, targets):
visible_map = self.get_visible_map()
- dijkstra_map = self.world.game.map_type(visible_map.size)
+ dijkstra_map = Map(visible_map.size)
n_max = 256
dijkstra_map.terrain = [n_max for i in range(dijkstra_map.size_i)]
for target in targets:
for pos in dijkstra_map:
if visible_map[pos] != '.':
continue
- neighbors = dijkstra_map.get_neighbors(tuple(pos))
+ neighbors = self.world.game.map_geometry.get_neighbors((YX(0,0), pos),
+ dijkstra_map.size)
for direction in neighbors:
- yx = neighbors[direction]
- if yx is not None and dijkstra_map[yx] < dijkstra_map[pos] - 1:
- dijkstra_map[pos] = dijkstra_map[yx] + 1
+ big_yx, small_yx = neighbors[direction]
+ if big_yx == YX(0,0) and \
+ dijkstra_map[small_yx] < dijkstra_map[pos] - 1:
+ dijkstra_map[pos] = dijkstra_map[small_yx] + 1
shrunk = True
- neighbors = dijkstra_map.get_neighbors(own_pos)
+ neighbors = self.world.game.map_geometry.get_neighbors((YX(0,0), own_pos),
+ dijkstra_map.size)
n = n_max
target_direction = None
for direction in sorted(neighbors.keys()):
- yx = neighbors[direction]
- if yx is not None:
- n_new = dijkstra_map[yx]
+ big_yx, small_yx = neighbors[direction]
+ if big_yx == (0,0):
+ n_new = dijkstra_map[small_yx]
if n_new < n:
n = n_new
target_direction = direction
return target_direction
def hunt_player(self):
- visible_things, offset = self.get_visible_things()
+ visible_things = self.get_visible_things()
+ offset = self.get_surroundings_offset()
target = None
for t in visible_things:
if t.type_ == 'human':
- target = (t.position[1][0] - offset[0],
- t.position[1][1] - offset[1])
+ target = t.position[1] - offset
break
if target is not None:
try:
- offset_self_pos = (self.position[1][0] - offset[0],
- self.position[1][1] - offset[1])
+ offset_self_pos = self.position[1] - offset
target_dir = self.move_on_dijkstra_map(offset_self_pos,
[target])
if target_dir is not None:
if t.type_ == 'food':
self.set_task('PICKUP', (id_,))
return True
- visible_things, offset = self.get_visible_things()
+ visible_things = self.get_visible_things()
+ offset = self.get_surroundings_offset()
food_targets = []
for t in visible_things:
if t.type_ == 'food':
- food_targets += [(t.position[1][0] - offset[0],
- t.position[1][1] - offset[1])]
- offset_self_pos = (self.position[1][0] - offset[0],
- self.position[1][1] - offset[1])
+ food_targets += [t.position[1] - offset]
+ offset_self_pos = self.position[1] - offset
target_dir = self.move_on_dijkstra_map(offset_self_pos,
food_targets)
if target_dir:
self._surrounding_map = None
self._surroundings_offset = None
- def must_fix_indentation(self):
- return self._radius % 2 != self.position[1][0] % 2
-
def get_surroundings_offset(self):
if self._surroundings_offset is not None:
return self._surroundings_offset
- add_line = self.must_fix_indentation()
- offset_y = self.position[1][0] - self._radius - int(add_line)
- offset_x = self.position[1][1] - self._radius
- self._surroundings_offset = (offset_y, offset_x)
+ offset = YX(self.position[0].y * self.world.game.map_size.y +
+ self.position[1].y - self._radius,
+ self.position[0].x * self.world.game.map_size.x +
+ self.position[1].x - self._radius)
+ self._surroundings_offset = offset
return self._surroundings_offset
def get_surrounding_map(self):
if self._surrounding_map is not None:
return self._surrounding_map
+ self._surrounding_map = Map(size=YX(self._radius*2+1, self._radius*2+1))
offset = self.get_surroundings_offset()
- add_line = self.must_fix_indentation()
- self._surrounding_map = self.world.game.\
- map_type(size=(self._radius*2+1+int(add_line),
- self._radius*2+1))
for pos in self._surrounding_map:
- offset_pos = (pos[0] + offset[0], pos[1] + offset[1])
- if offset_pos[0] >= 0 and \
- offset_pos[0] < self.world.maps[(0,0)].size[0] and \
- offset_pos[1] >= 0 and \
- offset_pos[1] < self.world.maps[(0,0)].size[1]:
- self._surrounding_map[pos] = self.world.maps[(0,0)][offset_pos]
+ offset_pos = pos + offset
+ big_yx, small_yx = self.world.game.map_geometry.absolutize_coordinate(self.world.game.map_size, (0,0), offset_pos)
+ map_ = self.world.get_map(big_yx, False)
+ if map_ is None:
+ map_ = Map(size=self.world.game.map_size)
+ self._surrounding_map[pos] = map_[small_yx]
return self._surrounding_map
def get_stencil(self):
if self._stencil is not None:
return self._stencil
- m = self.get_surrounding_map()
- offset = self.get_surroundings_offset()
- fov_center = (self.position[1][0] - offset[0],
- self.position[1][1] - offset[1])
- self._stencil = m.get_fov_map(fov_center)
+ surrounding_map = self.get_surrounding_map()
+ m = Map(surrounding_map.size, ' ')
+ for pos in surrounding_map:
+ if surrounding_map[pos] in {'.', '~'}:
+ m[pos] = '.'
+ fov_center = YX((m.size.y) // 2, m.size.x // 2)
+ self._stencil = FovMapHex(m, fov_center)
return self._stencil
def get_visible_map(self):
stencil = self.get_stencil()
- m = self.get_surrounding_map().new_from_shape(' ')
+ m = Map(self.get_surrounding_map().size, ' ')
for pos in m:
if stencil[pos] == '.':
m[pos] = self._surrounding_map[pos]
offset = self.get_surroundings_offset()
visible_things = []
for thing in self.world.things:
- if abs(thing.position[1][0] - self.position[1][0]) > self._radius or\
- abs(thing.position[1][1] - self.position[1][1]) > self._radius:
+ pos = self.world.game.map_geometry.pos_in_projection(thing.position,
+ offset,
+ self.world.game.map_size)
+ if pos.y < 0 or pos.x < 0 or\
+ pos.y >= stencil.size.y or pos.x >= stencil.size.x:
continue
- offset_pos = (thing.position[1][0] - offset[0],
- thing.position[1][1] - offset[1])
- if (not thing.in_inventory) and stencil[offset_pos] == '.':
+ if (not thing.in_inventory) and stencil[pos] == '.':
visible_things += [thing]
- return visible_things, offset
+ return visible_things
def get_pickable_items(self):
pickable_ids = []
- visible_things, _ = self.get_visible_things()
- for t in [t for t in visible_things if
- isinstance(t, ThingItem) and
+ visible_things = self.get_visible_things()
+ neighbor_fields = self.world.game.map_geometry.get_neighbors(self.position,
+ self.world.game.map_size)
+ for t in [t for t in visible_things
+ if isinstance(t, ThingItem) and
(t.position == self.position or
- t.position[1] in
- self.world.maps[(0,0)].get_neighbors(self.position[1]).values())]:
+ t.position in neighbor_fields.values())]:
pickable_ids += [t.id_]
return pickable_ids
projects / plomrogue2-experiments / blobdiff