def statue(self):
"""
The statue AI pattern is as follows:
If a monster that meets certain conditions is in view, do
a general haste.
If no such monster is in view, teleport adjacent to a damaged monster.
If no such monster exists, then teleport randomly.
"""
for d in self.fov.dudes:
if self.spec == "QUICKEN":
if (not d.isPlayer()) and (d.AICode != "STATUE"):
return action.HasteAll(self, 8, False, False)
else:
assert False
# If the statue is stuck, it can't teleport, so it just stays.
if self.hasCondition("STUCK"):
return action.Wait(self)
# If the statue did not do anything to monsters in view, it must teleport.
for m in self.currentLevel.dudeLayer:
if m.cur_HP < m.max_HP and not m.isPlayer() and (m.AICode !=
"STATUE"):
# Aha, a target!
destination_candidates = coordinates.adjacent_coords(m.coords)
destination_options = [
i for i in destination_candidates
if self.currentLevel.isEmpty(i)
and i not in self.currentLevel.dudeLayer
]
if destination_options != []:
return action.Teleport(self,
rng.choice(destination_options))
# If there are no monsters to which the statue can teleport, teleport randomly.
for i in range(100):
destination = rng.randomPointInRect(
(0, 0), (self.currentLevel.dimensions[0] - 1,
self.currentLevel.dimensions[1] - 1))
if self.currentLevel.isEmpty(destination) and \
destination not in self.currentLevel.dudeLayer:
return action.Teleport(self, destination)
return action.Wait(self)
def populate_level(pop_level, floor_def):
"""
Populate a given level with monsters.
"""
NUMBER_OF_MONSTERS = 9
level_nwcorner = (0, 0)
level_secorner = [dim - 1 for dim in pop_level.dimensions]
for i in range(NUMBER_OF_MONSTERS):
monster_to_be_made = floor_def.getRandomMonster()
monster_has_been_created = False
while not monster_has_been_created:
monster_coords = rng.randomPointInRect(level_nwcorner, level_secorner)
if pop_level.dungeonGlyph(monster_coords) in level.PASSABLE_TERRAIN and \
monster_coords not in pop_level.dudeLayer:
pop_level.addDude(monster_to_be_made, monster_coords, False)
monster_has_been_created = True
def randomDungeon():
"""
Gets a random dungeon, using a very simple room/corridor model.
The room/corridor model used is similar to that of Rogue; the map is
divided into nine sectors, each of which is randomly called a room,
a corridor, or empty. Once this is done, rooms and corridors are connected
to adjacent rooms and corridors.
This is coded terribly because it will be replaced someday.
"""
map_dimensions = (60, 60)
map_nwcorner = (10, 10)
sector_size = (12, 12)
sector_nwcorners = {}
for x in range(0, 3):
for y in range(0, 3):
sector_nwcorners[(x, y)] = (
map_nwcorner[0] + sector_size[0] * x,
map_nwcorner[1] + sector_size[1] * y
)
sector_types = {}
for x in range(0, 3):
for y in range(0, 3):
percent = rng.randInt(1, 100)
if percent <= 60:
sector_types[(x, y)] = 1 # it's a room!
elif percent <= 75:
sector_types[(x, y)] = 2 # it's a corridor!
else:
sector_types[(x, y)] = 0 # it's empty!
room_nwcoords = {}
room_secoords = {}
for sector_coords in sector_types.keys():
if sector_types[sector_coords] == 1:
room_created = False
sector_nw = sector_nwcorners[sector_coords]
sector_se = (sector_nw[0] + sector_size[0] - 1, sector_nw[1] + sector_size[1] - 1)
while not room_created:
room_nw = (rng.randInt(sector_nw[0], sector_se[0]),
rng.randInt(sector_nw[1], sector_se[1]))
room_se = (room_nw[0] + rng.randInt(3, 8),
room_nw[1] + rng.randInt(3, 8))
# check validity of room dimensions
if room_se[0] <= sector_se[0] and room_se[1] <= sector_se[1]:
room_nwcoords[sector_coords] = room_nw
room_secoords[sector_coords] = room_se
room_created = True
elif sector_types[sector_coords] == 2:
# A corridor is currently implemented as just a 1-space room.
corridor_coords = (rng.randInt(sector_nwcorners[sector_coords][0],
sector_nwcorners[sector_coords][0] + sector_size[0] - 1,),
rng.randInt(sector_nwcorners[sector_coords][1],
sector_nwcorners[sector_coords][1] + sector_size[1] - 1,))
room_nwcoords[sector_coords] = corridor_coords
room_secoords[sector_coords] = corridor_coords
# Check whether everywhere is accessible; if not, do a redo.
sector_is_accessible = {}
for x in range(3):
for y in range(3):
sector_is_accessible[(x, y)] = False
for coord in ((0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), (1, 2), (2, 2)):
if True not in sector_is_accessible.values() and sector_types[coord] != 0:
sector_is_accessible[coord] = True
if sector_is_accessible[coord] == True and sector_types[coord] != 0:
for coord_adjustment in ((1, 0), (0, 1), (-1, 0), (0, -1)):
adjacent_coord = coordinates.add(coord, coord_adjustment)
if (adjacent_coord[0] >= 0 and
adjacent_coord[0] < 3 and
adjacent_coord[1] >= 0 and
adjacent_coord[1] < 3):
sector_is_accessible[adjacent_coord] = True
for accessible in sector_is_accessible.items():
if sector_types[accessible[0]] != 0 and not accessible[1]:
# Oops. Give up and try again.
return randomDungeon()
entrance_sector = rng.choice([coords for coords in sector_types.keys() if sector_types[coords] == 1])
exit_sector = rng.choice([coords for coords in sector_types.keys() if sector_types[coords] == 1])
entrance_coords = rng.randomPointInRect(room_nwcoords[entrance_sector], room_secoords[entrance_sector])
exit_coords = rng.randomPointInRect(room_nwcoords[exit_sector], room_secoords[exit_sector])
ret_dungeon = level.empty_dungeon(map_dimensions)
for coord in ((0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), (1, 2), (2, 2)):
if sector_types[coord] != 0:
for x in range(room_nwcoords[coord][0], room_secoords[coord][0] + 1):
for y in range(room_nwcoords[coord][1], room_secoords[coord][1] + 1):
if sector_types[coord] == 1:
ret_dungeon[(x, y)] = level.ROOM_INTERIOR_GLYPH
else:
ret_dungeon[(x, y)] = level.CORRIDOR_GLYPH
for coord_adjustment in ((1, 0), (0, 1)):
adjacent_coord = coordinates.add(coord, coord_adjustment)
if (adjacent_coord[0] < 3 and adjacent_coord[1] < 3 and sector_types[adjacent_coord] != 0):
make_corridor(ret_dungeon,
rng.randomPointInRect(room_nwcoords[coord], room_secoords[coord]),
rng.randomPointInRect(room_nwcoords[adjacent_coord], room_secoords[adjacent_coord]))
ret_dungeon[entrance_coords] = level.UPSTAIRS_GLYPH
ret_dungeon[exit_coords] = level.DOWNSTAIRS_GLYPH
return ret_dungeon
def randomDungeon():
"""
Gets a random dungeon, using a very simple room/corridor model.
The room/corridor model used is similar to that of Rogue; the map is
divided into nine sectors, each of which is randomly called a room,
a corridor, or empty. Once this is done, rooms and corridors are connected
to adjacent rooms and corridors.
This is coded terribly because it will be replaced someday.
"""
map_dimensions = (MAX_SIZE_X, MAX_SIZE_Y)
map_nwcorner = (NW_CORNER_X, NW_CORNER_Y)
sector_size = (SECTOR_SIZE_X, SECTOR_SIZE_Y)
sector_list = [(x, y) for x in range(NUM_SECTORS_X)
for y in range(NUM_SECTORS_Y)]
sector_nwcorners = {}
for x in range(NUM_SECTORS_X):
for y in range(NUM_SECTORS_Y):
sector_nwcorners[(x, y)] = (
map_nwcorner[0] + sector_size[0] * x,
map_nwcorner[1] + sector_size[1] * y
)
sector_types = {}
for x in range(NUM_SECTORS_X):
for y in range(NUM_SECTORS_Y):
percent = rng.randInt(1, 100)
if percent <= 25:
sector_types[(x, y)] = st.ROOM
elif percent <= 60:
sector_types[(x, y)] = st.DOUBLE_ROOM
elif percent <= 75:
sector_types[(x, y)] = st.CORRIDOR
else:
sector_types[(x, y)] = st.EMPTY
room_nwcoords = {}
room_secoords = {}
for sector_coords in sector_types.keys():
sector_nw = sector_nwcorners[sector_coords]
sector_se = (sector_nw[0] + sector_size[0] - 1,
sector_nw[1] + sector_size[1] - 1)
if sector_types[sector_coords] in (st.ROOM, st.DOUBLE_ROOM):
(room_nwcoords[sector_coords], room_secoords[sector_coords]) \
= choose_room_corners(sector_nw, sector_se)
elif sector_types[sector_coords] == st.CORRIDOR:
# A corridor is currently implemented as just a 1-space room.
corridor_coords = (rng.randInt(sector_nw[0], sector_se[0]),
rng.randInt(sector_nw[1], sector_se[1]))
room_nwcoords[sector_coords] = corridor_coords
room_secoords[sector_coords] = corridor_coords
# Check whether everywhere is accessible; if not, do a redo.
sector_is_accessible = {}
for x in range(NUM_SECTORS_X):
for y in range(NUM_SECTORS_Y):
sector_is_accessible[(x, y)] = False
for coord in sector_list:
if True not in sector_is_accessible.values() \
and sector_types[coord] != 0:
sector_is_accessible[coord] = True
if sector_is_accessible[coord] == True \
and sector_types[coord] != st.EMPTY:
for coord_adjustment in ((1, 0), (0, 1), (-1, 0), (0, -1)):
adjacent_coord = coordinates.add(coord, coord_adjustment)
if (adjacent_coord[0] >= 0 and
adjacent_coord[0] < NUM_SECTORS_X and
adjacent_coord[1] >= 0 and
adjacent_coord[1] < NUM_SECTORS_Y):
sector_is_accessible[adjacent_coord] = True
for accessible in sector_is_accessible.items():
if sector_types[accessible[0]] != 0 and not accessible[1]:
# Oops. Give up and try again.
return randomDungeon()
entrance_sector = rng.choice([coords for coords in sector_types.keys()
if sector_types[coords] in
(st.ROOM, st.DOUBLE_ROOM)])
exit_sector = rng.choice([coords for coords in sector_types.keys()
if sector_types[coords] in
(st.ROOM, st.DOUBLE_ROOM)])
entrance_coords = rng.randomPointInRect(room_nwcoords[entrance_sector],
room_secoords[entrance_sector])
exit_coords = rng.randomPointInRect(room_nwcoords[exit_sector],
room_secoords[exit_sector])
ret_dungeon = level.empty_dungeon(map_dimensions)
for coord in sector_list:
if sector_types[coord] != st.EMPTY:
if sector_types[coord] == st.CORRIDOR:
fill_glyph = level.CORRIDOR_GLYPH
else:
fill_glyph = level.ROOM_INTERIOR_GLYPH
arrays.fill_rect(ret_dungeon, room_nwcoords[coord],
room_secoords[coord], fill_glyph)
# If there is another room to the south or east, make a corridor from this room
# to it.
for coord_adjustment in ((1, 0), (0, 1)):
adjacent_coord = coordinates.add(coord, coord_adjustment)
if (adjacent_coord[0] < NUM_SECTORS_X
and adjacent_coord[1] < NUM_SECTORS_Y
and sector_types[adjacent_coord] != 0):
make_corridor(ret_dungeon,
rng.randomPointInRect(room_nwcoords[coord],
room_secoords[coord]),
rng.randomPointInRect(room_nwcoords[adjacent_coord],
room_secoords[adjacent_coord]))
# If the room type is DOUBLE_ROOM, bolt on a second room to the first.
# This room can overflow! That is intentional.
if sector_types[coord] == st.DOUBLE_ROOM:
max_second_se = (room_secoords[coord][0] + MIN_ROOM_SIZE,
room_secoords[coord][1] + MIN_ROOM_SIZE)
(second_nw, second_se) = choose_room_corners(
room_nwcoords[coord], max_second_se)
arrays.fill_rect(ret_dungeon, second_nw, second_se,
level.ROOM_INTERIOR_GLYPH)
ret_dungeon[entrance_coords] = level.UPSTAIRS_GLYPH
ret_dungeon[exit_coords] = level.DOWNSTAIRS_GLYPH
return ret_dungeon
