def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, colors):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# 'rect' class makes rectangles easy
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# no intersections, it's a good room
self.create_room(new_room)
# center coordinates of new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this means it is first room
player.x = new_x
player.y = new_y
else:
# all rooms after first
# connec to previous room
# center coords of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random 0, or 1)
if randint(0, 1) == 1:
# make horizontal tunnel first
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# make vertical tunnel first
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# add monsters to the room
self.place_entities(new_room, entities, colors)
# append new room to rooms
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(game_map,
max_rooms,
room_min_size,
room_max_size,
map_width,
map_height,
player,
entities,
colors,
lexicon,
direction=None):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# Run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
# paint it to the map's tiles
create_room(game_map, new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1):
# first move horizontally, then vertically
create_h_tunnel(game_map, prev_x, new_x, prev_y)
create_v_tunnel(game_map, prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
create_v_tunnel(game_map, prev_y, new_y, prev_x)
create_h_tunnel(game_map, prev_x, new_x, new_y)
place_entities(new_room, entities, game_map.dungeon_level, colors,
lexicon)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
if direction == 'down':
down_stairs_component = Stairs(game_map.dungeon_level + 1, 'down')
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>', (255, 255, 255),
'Down Stairs',
render_order=RenderOrder.STAIRS,
stairs=down_stairs_component)
entities.append(down_stairs)
up_stairs_component = Stairs(game_map.dungeon_level - 1, 'up')
up_stairs = Entity(player.x,
player.y,
'<', (255, 255, 255),
'Up Stairs',
render_order=RenderOrder.STAIRS,
stairs=up_stairs_component)
entities.append(up_stairs)
elif direction == 'up':
down_stairs_component = Stairs(game_map.dungeon_level + 1, 'down')
down_stairs = Entity(player.x,
player.y,
'>', (255, 255, 255),
'Down Stairs',
render_order=RenderOrder.STAIRS,
stairs=down_stairs_component)
entities.append(down_stairs)
up_stairs_component = Stairs(game_map.dungeon_level - 1, 'up')
up_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'<', (255, 255, 255),
'Up Stairs',
render_order=RenderOrder.STAIRS,
stairs=up_stairs_component)
entities.append(up_stairs)
else:
down_stairs_component = Stairs(game_map.dungeon_level + 1, 'down')
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>', (255, 255, 255),
'Down Stairs',
render_order=RenderOrder.STAIRS,
stairs=down_stairs_component)
entities.append(down_stairs)
# choose a random room from all rooms except the first and the last, to put a fountain of health
fountain_location = rooms[randint(1, len(rooms) - 2)]
(fountain_x, fountain_y) = fountain_location.center()
fountain_component = Fountain(20 * game_map.dungeon_level)
fountain = Entity(fountain_x,
fountain_y,
'+',
colors.get('blue'),
'Fountain',
render_order=RenderOrder.ITEM,
fountain=fountain_component)
entities.append(fountain)
def make_map(self, max_rooms: int, room_min_size: int, room_max_size: int, map_width: int,
map_height: int, player: Entity):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
x = randint(0, map_width - w - 2)
y = randint(0, map_height - h - 2)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
self.dig_room(new_room)
new_x, new_y = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
player.x = new_x
player.y = new_y
self.start_x = new_x
self.start_y = new_y
else:
other = find_nearest_room(new_room, rooms)
prev_x, prev_y = other.center()
# new_x, new_y = new_room.center()
# print(f"\t\tNearest room to {(new_x, new_y)} is {(prev_x, prev_y)}")
if randint(0, 1) == 1:
self.dig_h_tunnel(new_x, prev_x, new_y)
self.dig_v_tunnel(prev_x, prev_y, new_y)
else:
self.dig_v_tunnel(new_x, new_y, prev_y)
self.dig_h_tunnel(new_x, prev_x, prev_y)
if num_rooms > 0:
self.place_entities(new_room)
rooms.append(new_room)
num_rooms += 1
self.end_x = center_of_last_room_x
self.end_y = center_of_last_room_y
down_stairs_component = Stairs(1)
down_stairs = Entity("Stairs", EntityType.STAIRS, center_of_last_room_x, center_of_last_room_y, ord('>'),
(255, 255, 255), stairs=down_stairs_component)
self.entities.append(down_stairs)
if self.dungeon_level > 1:
up_stairs_component = Stairs(-1)
up_stairs = Entity("Stairs", EntityType.STAIRS, player.x, player.y, ord('<'),
(255, 255, 255), stairs=up_stairs_component)
self.entities.append(up_stairs)
def make_map(game_map, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, colors):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position withut going outside bounds of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# run through other rooms and see if intersection occurs
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# no intersections
# 'paint' to map's tiles
create_room(game_map, new_room)
# center coordinates of new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
#this is the first room, where the player starts
player.x = new_x
player.y = new_y
else:
# all rooms after first
# connect to previous room with tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
create_h_tunnel(game_map, prev_x, new_x, prev_y)
create_v_tunnel(game_map, prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
create_v_tunnel(game_map, prev_y, new_y, prev_x)
create_h_tunnel(game_map, prev_x, new_x, new_y)
place_entities(new_room, entities, game_map.dungeon_level, colors)
#finally, append new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(game_map.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>', (255, 255, 255),
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
"""
Creates the map. Chisels out all of the rooms and paths. Places all entities.
Places a stairway in the middle of the last room.
:param max_rooms: Integer.
:param room_min_size: Integer.
:param room_max_size: Integer.
:param map_width: Integer.
:param map_height: Integer.
:param player: The player's entity object.
:param entities: The list of entities
:param max_monsters_per_room: Integer of max monsters per room.
:return: None
"""
# Stores the rooms in a list.
rooms = []
# Counts the number of rooms currently created.
num_rooms = 0
# Stores the centre of the last room to place the stairs here.
centre_of_last_room_x = None
centre_of_last_room_y = None
####### SPAWNS ROOMS #######
for r in range(max_rooms):
# Generates a random room width and height.
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# Generates a random position without going outside the map boundaries.
# Subtracts 1 because the top corner is a wall tile not the inside of the room -
# Without subtracting 1 the outer right/bottom wall could be destroyed.
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# Makes a new rectangular room using the newly generated values.
new_room = Rect(x, y, w, h)
# Runs through the other rooms and checks if they intersects with this one.
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# NICE USE OF THIS FOR/ELSE! If the for loop doesn't break else is ran.
# If the new room did not intersect with any other room it will be built.
# Creates the room.
self.create_room(new_room)
# Stores the centre coordinates of the new room.
(new_x, new_y) = new_room.center()
# Will end up storing the centre of the last room for stair placement.
centre_of_last_room_x = new_x
centre_of_last_room_y = new_y
# Puts the player in the centre of the first room.
if num_rooms == 0:
player.x = new_x
player.y = new_y
# If the number of rooms in the list is NOT 0.
else:
# All rooms after the first.
# Connect it to the previous room with a tunnel.
# Centre coordinates of the previous room.
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# Flip a coin (Random number that is either 0 or 1)
if randint(0, 1) == 1:
# First move horizontally, then vertically.
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# First move vertically, then horizontally.
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# Spawns entities (the player was already spawned earlier).
self.place_entities(new_room, entities)
# Finally, append the new room to the room list.
rooms.append(new_room)
num_rooms += 1
# Creates the stairs component - sets its level to the next dungeon level directly below.
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(centre_of_last_room_x,
centre_of_last_room_y,
">",
libtcod.white,
"Stairs",
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_max_size, room_min_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = 0
center_of_last_room_y = 0
for r in range(max_rooms):
# generates random room size
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# generates random room location in the map and not overlapping
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# checks for room intersections
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# if no intersections
self.create_room(new_room)
(new_x, new_y) = new_room.center()
if num_rooms == 0:
# the first room contains the player in its center
player.x = new_x
player.y = new_y
else:
# finds center of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
# flips a coin to find order of tunnel generation
if randint(0, 1) == 0:
# moves horizontally then vertically
self.create_horizontal_tunnel(prev_x, new_x, prev_y)
self.create_vertical_tunnel(prev_y, new_y, new_x)
else:
# moves vertically then horizontally
self.create_horizontal_tunnel(prev_x, new_x, new_y)
self.create_vertical_tunnel(prev_y, new_y, prev_x)
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
">",
libtcod.white,
"Stairs",
False,
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities,):
"""
Create rooms for dungeon map
"""
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going outside the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# 'Rect' class to make rooms
new_room = Rect(x, y, w, h)
# Run through other rooms to make sure it doesnt intersect
for other_rooms in rooms:
if new_room.intersect(other_rooms):
break
else:
# This will action if there are no intersections
# unblock map tiles
self.create_room(new_room)
# center coordinates for new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# Upon creation of first room
player.x = new_x
player.y = new_y
else:
"""
for all rooms after the first one
connect the current room to the previous room
"""
# Coordinates of the previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# Randomise the direction of the tunnel 1 == horizontal
if randint(0, 1) == 1:
# Move horizontal then vertical
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# move vertical then horizontal
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities, )
# Finally add the new room to the room list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', tcod.white, 'stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# Random height and width of room
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# Random position within boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersects(other_room):
break
else:
self.create_room(new_room)
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if len(rooms) == 0:
# Start player in the first room
player.x = new_x
player.y = new_y
print("player starting position set")
else:
# All rooms after the first:
# connect it to the prev one with a tunnel
# Center coords of prev room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# Flip a coin whether to go vert or hor first
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(new_x, prev_y, new_y)
else:
self.create_v_tunnel(prev_x, prev_y, new_y)
self.create_h_tunnel(prev_x, new_x, new_y)
# Append the new room to the list of rooms
rooms.append(new_room)
self.place_entities(new_room, entities)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, player, entities):
start_time = time.time()
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
# Essentially, this algorithm generates a random room, and checks to see if it intesects with the generated map (if it does, it breaks)
# If not, it generates the room, and using the center of that room, connects that room with a tunnel to the previously generated room
# if it's the first room, it plops the player in the middle of it
# Then fill it with stuff and keep going
for r in range(game_constants.max_rooms):
w = randint(game_constants.room_min_size,
game_constants.room_max_size)
h = randint(game_constants.room_min_size,
game_constants.room_max_size)
x = randint(0, game_constants.map_width - w - 1)
y = randint(0, game_constants.map_height - h - 1)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
self.create_room(new_room)
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
player.x = new_x
player.y = new_y
libtcod.mouse_move(player.x, player.y)
else:
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.populate_room(new_room, entities)
rooms.append(new_room)
num_rooms += 1
# Once all of the rooms have been generated, plot the stairs in the middle of the last room created
stairs_components = {"Stairs": Stairs(self.dungeon_level + 1)}
stairs_entity = Entity(center_of_last_room_x,
center_of_last_room_y,
">",
libtcod.white,
"Stairs Down",
blocks=True,
render_order=RenderOrder.ACTOR,
message_log=self.log,
state=AIStates.INANIMATE,
components=stairs_components)
self.tiles[center_of_last_room_x][center_of_last_room_y].add_entity(
stairs_entity)
entities.insert_entity(stairs_entity)
self.compute_dijkstra_map([stairs_entity], "stairs")
print("Map generated in {} seconds".format(time.time() - start_time))
def make_map(self, max_rooms: int, room_min_size: int, room_max_size: int,
map_width: int, map_height: int, player, entities):
rooms: List[Rect] = []
num_rooms: int = 0
item_components = get_item_classes()
center_of_last_room_x: int
center_of_last_room_y: int
for r in range(max_rooms):
w: int = randint(room_min_size, room_max_size)
h: int = randint(room_min_size, room_max_size)
x: int = randint(0, map_width - w - 1)
y: int = randint(0, map_height - h - 1)
new_room: Rect = Rect(x, y, w, h)
# for-else loop
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
# "paint" it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.pos.x = new_x
player.pos.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities, item_components)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
pos_comp = Position(center_of_last_room_x, center_of_last_room_y)
down_stairs = Entity('>',
tcod.white,
'Stairs',
position=pos_comp,
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, max_monsters_per_room,
max_items_per_room):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random room size
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random room location within boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# make sure rooms don't intersect
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# no intersections with any other rooms - place it
self.create_room(new_room)
# place player in center of first valid room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
player.x = new_x
player.y = new_y
else:
# we'll need to connect rooms with tunnels
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
# hor -> vert
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# vert -> hor
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities, max_monsters_per_room,
max_items_per_room)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(
self,
max_rooms,
room_min_size,
room_max_size,
map_width,
map_height,
player,
entities,
max_monsters_per_room,
max_items_per_room,
):
""" Given max num of rooms: create them + connect with tunnels
"""
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for _ in range(max_rooms):
# random width and height
width = randint(room_min_size, room_max_size)
height = randint(room_min_size, room_max_size)
# random position without going out of the bounds of the map
x_pos = randint(0, map_width - width - 1)
y_pos = randint(0, map_height - height - 1)
new_room = Rect(x_pos, y_pos, width, height)
# run through other rooms to see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# valid room
self.create_room(new_room)
# center the coordinates of the new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts
player.x_pos = new_x
player.y_pos = new_y
else:
# all rooms after the first
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin
if randint(0, 1) == 1:
# move horizontally, then vertically
self.create_horizontal_tunnel(prev_x, new_x, prev_y)
self.create_vertical_tunnel(prev_y, new_y, new_x)
else:
# move vertically, then horizontally
self.create_vertical_tunnel(prev_y, new_y, prev_x)
self.create_horizontal_tunnel(prev_x, new_x, new_y)
# add monsters
self.place_entities(new_room, entities, max_monsters_per_room,
max_items_per_room)
# append new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs',
RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, max_monsters_per_room,
max_items_per_room):
# Create rooms
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# Random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# Random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# Make the rectangle to work with
new_room = Rect(x, y, w, h)
# Check to see if new room intersects with any existing rooms
for other_room in rooms:
if new_room.intersect(other_room):
break
# No intersections, so we can make the room
else:
# "Paint" the room to the map's tiles
self.create_room(new_room)
new_x, new_y = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
# If we are making the first room, put the player in it
if num_rooms == 0:
player.x = new_x
player.y = new_y
# All rooms after the first one
else:
prev_x, prev_y = rooms[num_rooms - 1].center()
# 50/50 chance at which order we connect the new room to the previous
if randint(0, 1) == 1:
# Make tunnel horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# Make tunnel vertically then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# Add monsters to the room
self.place_entities(new_room, entities, max_monsters_per_room,
max_items_per_room)
# Append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
"Stairs",
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
"""Randomly generates rooms and tunnels between them based on the map dimensions,
and also sets the player's position to be the center of the first room.
"""
rooms = [] # List of room objects
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without leaving the map boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# 'Rect' class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# go through other rooms and check if they intersect
for other_room in rooms:
if new_room.intersect(other_room):
break
else: # Python for-else: the else runs if for doesn't break!
# No intersections: room is valid - so actually create it!
self.create_room(new_room)
# center coordinates of new room, for later
new_x, new_y = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# This is the first room, where the player starts
player.x = new_x
player.y = new_y
else:
# all rooms after the first: connect to previous with a tunnel
prev_x, prev_y = rooms[num_rooms - 1].center()
# flip a coin on moving horiz then vert, or vert then horiz
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# Place entities into the room
self.place_entities(new_room, entities)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities, pet, direction):
rooms = []
num_rooms = 0
if self.dungeon_level < 6:
self.biome = 'The Dungeon'
elif self.dungeon_level < 11:
self.biome = 'The Icebleak Cavern'
elif self.dungeon_level < 16:
self.biome = 'The Underglade'
elif self.dungeon_level < 21:
self.biome = 'The Hadalrealm'
elif self.dungeon_level < 24:
self.biome = 'Dragonroost'
elif self.dungeon_level == 24:
self.biome = 'Oblivion\'s Gate'
elif self.dungeon_level == 25:
self.biome = 'The Vault'
center_of_last_room_x = None
center_of_last_room_y = None
if self.dungeon_level < 24:
for r in range(max_rooms):
# random width and height
w = libtcod.random_get_int(0, room_min_size, room_max_size)
h = libtcod.random_get_int(0, room_min_size, room_max_size)
# random position without going out of the boundaries of the map
x = libtcod.random_get_int(0, 0, map_width - w - 1)
y = libtcod.random_get_int(0, 0, map_height - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
# "paint" it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
player_room = new_room
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
self.create_tunnel(prev_x, new_x, prev_y, new_y)
if new_room != player_room:
place_entities(self, new_room, entities)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
else:
for i in range(0, 3):
room = Rect(int(i*(map_width/4)), 0, int(map_width/4), map_height - 1)
room2 = Rect(0, int(i*(map_height/3)), map_width - 1, int(map_height/3))
self.create_room(room)
self.create_room(room2)
player.x, player.y = 10, 10
num_rooms += 2
rooms.append(room)
rooms.append(room2)
room = Rect(int(3 * (map_width / 4)), 0, int(map_width / 4) - 1, map_height - 1)
self.create_room(room)
num_rooms += 1
rooms.append(room)
center_of_last_room_x, center_of_last_room_y = 40, 21
if direction == 'down':
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', libtcod.white, 'Down Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
stairs_component = Stairs(self.dungeon_level - 1)
up_stairs = Entity(player.x, player.y, '<', libtcod.white, 'Up Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
if direction == 'up':
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(player.x, player.y, '>', libtcod.white, 'Down Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
stairs_component = Stairs(self.dungeon_level - 1)
up_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '<', libtcod.white, 'Up Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
if self.dungeon_level != 25:
entities.append(down_stairs)
if self.dungeon_level != 1:
entities.append(up_stairs)
if self.dungeon_level == 24:
fighter_component = Fighter(hp=300, defence=50, power=30)
ai_component = BasicMonster()
monster = Entity(40, 21, 'W', libtcod.white, 'DragonLord', blocks=True,
render_order=RenderOrder.ACTOR, fighter=fighter_component, ai=ai_component,
poisons_chance=100, burns_chance=100, freezes_chance=25, monster_class='(Dragon)')
entities.append(monster)
if pet:
ai_component = BasicPet()
fighter_component = Fighter(hp=pet.fighter.hp + 50, power=self.dungeon_level, defence=int(self.dungeon_level/2))
pet = Entity(player.x - 1, player.y, 'P', libtcod.blue, 'Pet', render_order=RenderOrder.ACTOR, fighter=fighter_component,
ai=ai_component, blocks=True, monster_class='(Pet)')
entities.append(pet)
return pet
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of the boundarties of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
self.create_room(new_room)
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0: # First room, player starts here.
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with tunnel.
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin
if randint(0, 1) == 1:
# first move horizontal and then vertical
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# do the opposite
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self,
max_rooms,
room_min_size,
room_max_size,
map_width,
map_height,
player,
entities):
rooms = []
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
width = randint(room_min_size, room_max_size)
height = randint(room_min_size, room_max_size)
# random position without going out of bounds
x = randint(0, map_width - width - 1)
y = randint(0, map_height - height - 1)
# create rectangle from specs
new_room = Rect(x, y, width, height)
# run through other rooms and check for intersections
for other_room in rooms:
if new_room.is_intersecting(other_room):
break
else:
# no intersections
# make room walkable
self.create_room(new_room)
# get center coordinates of new room
(new_center_x, new_center_y) = new_room.get_center_coords()
center_of_last_room_x = new_center_x
center_of_last_room_y = new_center_y
if len(rooms) == 0:
# starting room for player
player.x = new_center_x
player.y = new_center_y
else:
# connect new room to previous room
(prev_center_x, prev_center_y) = rooms[-1].get_center_coords()
# create random tunnel
if randint(0, 1):
# move horizontally then vertically
self.create_horiz_tunnel(prev_center_x, new_center_x, prev_center_y)
self.create_vert_tunnel(prev_center_y, new_center_y, new_center_x)
else:
# move vertically then horizontally
self.create_vert_tunnel(prev_center_y, new_center_y, prev_center_x)
self.create_horiz_tunnel(prev_center_x, new_center_x, new_center_y)
# fill with monsters
self.place_entities_in_room(new_room, entities)
# append new room to list
rooms.append(new_room)
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(
center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
"Stairs Down",
render_order=RenderOrder.STAIRS,
stairs=stairs_component
)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
#Creates up to 'max_rooms' and connects them all together
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
#random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
#random position with map boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
#Make our rooms Rect objects to handle them better
new_room = Rect(x, y, w, h)
#Make sure our new room does not intersect with our other rooms
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
#We did not intersect so we can create our room
#first carve it out from our tile map
self.create_room(new_room)
#then get its center coords
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
player.x = new_x
player.y = new_y
else:
#All rooms besides first need to connect to
#the last created room
#get previous rooms center coords
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def from_json(json_data):
x = json_data.get('x')
y = json_data.get('y')
char = json_data.get('char')
color_o = json_data.get('color')
color = libtcod.Color(color_o[0], color_o[1], color_o[2])
name = json_data.get('name')
blocks = json_data.get('blocks', False)
render_order = RenderOrder(json_data.get('render_order'))
fighter_json = json_data.get('fighter')
ai_json = json_data.get('ai')
item_json = json_data.get('item')
inventory_json = json_data.get('inventory')
stairs_json = json_data.get('stairs')
level_json = json_data.get('level')
equipment_json = json_data.get('equipment')
equippable_json = json_data.get('equippable')
uID_data = json_data.get('uID')
quickuse_json = json_data.get('quick_use')
entity = Entity(x,
y,
char,
color,
name,
blocks,
render_order,
uID=uID_data)
if fighter_json:
entity.fighter = Fighter.from_json(fighter_json)
entity.fighter.owner = entity
if ai_json:
name = ai_json.get('name')
if name == BasicMonster.__name__:
ai = BasicMonster.from_json()
elif name == ConfusedMonster.__name__:
ai = ConfusedMonster.from_json(ai_json, entity)
else:
ai = None
if ai:
entity.ai = ai
entity.ai.owner = entity
if item_json:
entity.item = Item.from_json(item_json)
entity.item.owner = entity
if inventory_json:
entity.inventory = Inventory.from_json(inventory_json)
entity.inventory.owner = entity
if stairs_json:
entity.stairs = Stairs.from_json(stairs_json)
entity.stairs.owner = entity
if level_json:
entity.level = Level.from_json(level_json)
entity.level.owner = entity
if equipment_json:
entity.equipment = Equipment.from_json(equipment_json)
entity.equipment.owner = entity
if equippable_json:
entity.equippable = Equippable.from_json(equippable_json)
entity.equippable.owner = entity
if quickuse_json:
entity.quick_use = Quickuse.from_json(quickuse_json)
entity.quick_use.owner = entity
return entity
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for _ in range(max_rooms):
# ランダムで幅と高さを決める
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# マップの範囲内でランダムな位置の指定
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# "Rect" クラスで部屋を生成する
new_room = Rect(x, y, w, h)
# 部屋と部屋が重複するかの判定
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# 重複が無ければ部屋を作成
self.create_room(new_room)
# 作成した部屋の中心座標を変数に格納
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# 初回はとりあえずplayerが居る最初の部屋の作成だけしてroomsリストに追加しnum_roomsに＋１する
player.x = new_x
player.y = new_y
else:
# 二回目以降に前の部屋の中心座標を変数prev_x,yに入れる(当然新しい部屋の座標はnew_x,yに入っている)
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# 前の部屋の中心座標と現在の部屋の中心座標からトンネル関数で部屋を彫っていく
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# ここでモンスターたちを部屋に配置する
self.place_entities(new_room, entities)
# 新しい部屋をリストに追加する
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
">",
libtcod.white,
"Stairs",
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, entities, moving_down=True):
if self.encounter:
self.encounter.setup_map_boundaries(0, self.owner.width - 1, 0, self.owner.height - 1)
self.encounter.make_rect()
rooms = [self.encounter.rect]
self.create_room(rooms[0])
num_rooms = 1
else:
rooms = []
num_rooms = 0
for _ in range(self.max_rooms):
# random width and height
w = randint(self.room_min_size, self.room_max_size)
h = randint(self.room_min_size, self.room_max_size)
# random position without going out of the boundaries of the map
x = randint(0, self.owner.width - w - 1)
y = randint(0, self.owner.height - h - 1)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
self.create_room(new_room)
new_x, new_y = new_room.center()
if num_rooms == 0 or (self.encounter and num_rooms == 1):
self.player_start = (new_x, new_y)
self.place_player(entities.player)
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
self.connect_room(new_room, rooms[num_rooms - 1])
self.fauna.populate_room(new_room, self.owner.dungeon_level, entities)
self.loot.fill_room(new_room, self.owner.dungeon_level, entities)
self.flora.grow_fungi_in_room(self.owner, new_room)
rooms.append(new_room)
num_rooms += 1
if moving_down:
down_stairs_x = new_x
down_stairs_y = new_y
up_stairs_x = entities.player.x
up_stairs_y = entities.player.y
else:
down_stairs_x = entities.player.x
down_stairs_y = entities.player.y
up_stairs_x = new_x
up_stairs_y = new_y
if not self.encounter:
stairs_component = Stairs(self.owner.dungeon_level + 1)
down_stairs = Entity(down_stairs_x, down_stairs_y, char='>', color=tcod.white,
name='Stairs down', render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
if self.owner.dungeon_level == 1:
direction = StairsDirections.WORLD
stairs_name = 'Stairs outside'
else:
direction = StairsDirections.UP
stairs_name = 'Stairs up'
up_stairs_component = Stairs(self.owner.dungeon_level, direction=direction)
up_stairs = Entity(up_stairs_x, up_stairs_y, char='<', color=tcod.white,
name=stairs_name, render_order=RenderOrder.STAIRS,
stairs=up_stairs_component)
entities.append(up_stairs)
if self.encounter:
self.connect_room(rooms[0], rooms[randint(1, len(rooms) - 1)])
self.encounter.create_on(self.owner, entities)
for x in range(self.owner.width):
for y in range(self.owner.height):
tile = self.owner.tiles[x][y]
if 'blocked' in tile.regulatory_flags:
tile.set_bg_color(self.material['wall'])
else:
tile.set_bg_color(self.material['floor'])
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, graphics):
"""
Cree un nombre de salles inferieur a un nombre fixe (s'arrete lorsque la generation aleatoire cree
deux pieces qui s'intersectent. Place le joueur dans la premiere d'entre elles, puis connecte la nouvelle
salle avec la precedente et enfin ajoute les escaliers a la liste des entites du jeu
Parametres:
----------
max_rooms : int
room_min_size : int
room_max_size : int
map_width : int
map_height : int
player : Entity
entities : list
graphics : dict
Renvoi:
-------
entities : list
retourne la liste des entités avec les monstres et les objets placés
"""
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# Coupe la boucle si la pièce créée intersecte d'autres déjà créées
for other_room in rooms:
if new_room.intersect(other_room):
break
# Si la pièce créée est valide, la relie à la précédente et place les entités
else:
self.create_room(new_room)
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
player.x = new_x
player.y = new_y
else:
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
entities = self.place_entities(new_room, entities, graphics)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
graphics.get('stairs'),
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
return entities
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
'''
Creates map of current dungeon floor
'''
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random pos in map boundaries
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# use rectangle room class
new_room = Rect(x, y, w, h)
# check for intersecting rooms
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
self.create_room(new_room)
# center coordinates of new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# starting room
player.x = new_x
player.y = new_y
else:
# all rooms after the first
# connect to previous room with tunnels
if num_rooms == 1: #and (randint(0, 2) == 1):
#33% chance of generating a shop on second room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
shopkeep_component = Shopkeep(True)
inventory_component = Inventory(25)
shopkeeper = Entity(new_x,
new_y,
'$',
libtcod.Color(5, 5, 5),
'Shopkeeper',
blocks=True,
render_order=RenderOrder.SHOPKEEP,
shopkeep=shopkeep_component,
inventory=inventory_component)
shopkeep_inventory = [
's_healing_potion', 'm_healing_potion',
'l_healing_potion', 'full_healing_salve',
'valkyrie_helm', 'hulidshjalmr', 'falcon_cloak',
'golden_coat', 'dwarven_leggings',
'leggings_of_odin', 'dwarven_boots',
'shoes_of_vidarr', 'megingjord', 'shield_of_hel',
'svallin', 'hrotti', 'dainsleif', 'tyrfing',
'gungnir', 'mjolnir', 'confusion_scroll',
'lightning_scroll', 'fireball_scroll', 'mistletoe',
'ragnarok'
]
for item in shopkeep_inventory:
item = get_item(item, 0, 0)
shopkeeper.inventory.add_item(item)
entities.append(shopkeeper)
else:
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# random choice of tunnel
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
# append the new room to the list
rooms.append(new_room)
num_rooms += 1
# create stairs entity in center of last room
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, player, entities):
rooms = []
num_rooms = 0
up_stairs = None
down_stairs = None
# Create the marketplace on the topmost level
if self.dungeon_level == 0:
self.make_market(player, entities)
elif self.dungeon_level == MAX_LEVELS:
w = randint(ROOM_MAX_SIZE + 4, ROOM_MAX_SIZE + 4)
h = randint(ROOM_MAX_SIZE + 4, ROOM_MAX_SIZE + 4)
x = MAP_WIDTH // 2
y = MAP_HEIGHT // 2
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# "paint" it to the map's tiles
self.create_room(new_room)
(new_x, new_y) = new_room.center()
player.x = new_x
player.y = new_y
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
else:
for r in range(MAX_ROOMS):
# random width and height
w = randint(ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = randint(ROOM_MIN_SIZE, ROOM_MAX_SIZE)
# random position without going out of the boundaries of the map
x = randint(0, MAP_WIDTH - w - 1)
y = randint(0, MAP_HEIGHT - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
intersects = False
# run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
intersects = True
break
if not intersects:
# this means there are no intersections, so this room is valid
# "paint" it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
centre_of_last_room_x = new_x
centre_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
# finally, append the new room to the list
# Put stairs in the world ordering based on where the player just came from
# i.e. if the player came from the floor below then the player should start with stairs going down
if self.previous_level < self.dungeon_level:
if up_stairs is None:
stairs_component = Stairs(self.dungeon_level - 1)
up_stairs = Entity(centre_of_last_room_x,
centre_of_last_room_y,
UP_STAIRS_CHAR,
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(up_stairs)
elif down_stairs is None:
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(
centre_of_last_room_x,
centre_of_last_room_y,
DOWN_STAIRS_CHAR,
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
else:
if down_stairs is None:
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(
centre_of_last_room_x,
centre_of_last_room_y,
DOWN_STAIRS_CHAR,
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
elif up_stairs is None:
stairs_component = Stairs(self.dungeon_level - 1)
up_stairs = Entity(centre_of_last_room_x,
centre_of_last_room_y,
UP_STAIRS_CHAR,
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(up_stairs)
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
def make_map(self, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# There are no intersections, so the room is valid
# Paint map tile
self.create_room(new_room)
# Center room coords
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# First room aka player rom
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# Connect to the previous room with a tunnel
# Center coords of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
if randint(0, 1) == 1:
# First move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# First move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x, center_of_last_room_y, '>', libtcod.white, 'Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height of room
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position within map bounds
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# Check if new room intersects with others
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# if room check didnt break, add new room to map tiles
self.create_room(new_room)
# center coord of room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# if this is first room, player starts here
player.x = new_x
player.y = new_y
else:
# for all rooms after first, connect to previous room with tunnel
# center coords of prev room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# Flip a coin
if randint(0, 1) == 1:
# First move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# or vice versa
self.create_h_tunnel(prev_x, new_x, new_y)
self.create_v_tunnel(prev_y, new_y, prev_x)
self.place_entities(new_room, entities)
# Finally, append new room to list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs Down',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
class GameMap:
def __init__(self, width, height, dungeon_level=1):
self.width = width
self.height = height
self.tiles = self.initialize_tiles()
self.dungeon_level = dungeon_level
def initialize_tiles(self):
tiles = [[Tile(True) for y in range(self.height)]
for x in range(self.width)]
return tiles
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, max_monster_per_room,
max_items_per_room):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# 'Rect' class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
# 这个else的缩进错误，花费了1小时去修正
else:
# this means there are no intersections, so this rooms is valid
# 'paint' it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# all rooms after the first
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin(random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities, max_monster_per_room,
max_items_per_room)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
tcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def create_room(self, room):
# go throught the tiles in the rectangele and make them passable
for x in range(room.x1 + 1, room.x2):
for y in range(room.y1 + 1, room.y2):
self.tiles[x][y].blocked = False
self.tiles[x][y].block_sight = False
def create_h_tunnel(self, x1, x2, y):
for x in range(min(x1, x2), max(x1, x2) + 1):
self.tiles[x][y].blocked = False
self.tiles[x][y].block_sight = False
def create_v_tunnel(self, y1, y2, x):
for y in range(min(y1, y2), max(y1, y2) + 1):
self.tiles[x][y].blocked = False
self.tiles[x][y].block_sight = False
def place_entities(self, room, entities, max_monsters_per_room,
max_items_per_room):
# Get a random number of monsters
number_of_monster = randint(0, max_monsters_per_room)
number_of_items = randint(0, max_items_per_room)
for i in range(number_of_monster):
# Choose a random location in the room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]):
if randint(0, 100) < 80:
fighter_component = Fighter(hp=10, defense=0, power=3)
ai_component = BasicMonster()
monster = Entity(x,
y,
'o',
tcod.desaturated_green,
'Orc',
blocks=True,
render_order=RenderOrder.ACTOR,
fighter=fighter_component,
ai=ai_component)
else:
fighter_component = Fighter(hp=16, defense=1, power=4)
ai_component = BasicMonster()
monster = Entity(x,
y,
'T',
tcod.darker_green,
'Troll',
blocks=True,
fighter=fighter_component,
render_order=RenderOrder.ACTOR,
ai=ai_component)
entities.append(monster)
for i in range(number_of_monster):
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]):
item_chance = randint(0, 100)
if item_chance < 70:
item_component = Item(use_function=heal, amount=4)
item = Entity(x,
y,
'!',
tcod.violet,
'Healing Potion',
render_order=RenderOrder.ITEM,
item=item_component)
elif item_chance < 80:
item_component = Item(
use_function=cast_fireball,
targeting=True,
targeting_message=Message(
'Left-click a target tile for the fireball, or right-click to cancel.',
tcod.light_cyan),
damage=12,
radius=3)
item = Entity(x,
y,
"#",
tcod.red,
'Fireball Scroll',
render_order=RenderOrder.ITEM,
item=item_component)
elif item_chance < 90:
item_component = Item(
use_function=cast_confuse,
targeting=True,
targeting_message=Message(
'Left-click an enemy to confuse it, or right-click to cancel.',
tcod.light_cyan))
item = Entity(x,
y,
'#',
tcod.light_pink,
'Confusion Scroll',
render_order=RenderOrder.ITEM,
item=item_component)
else:
item_component = Item(use_function=cast_lightning,
damage=20,
maximum_range=5)
item = Entity(x,
y,
'#',
tcod.yellow,
'Lightning Scroll',
render_order=RenderOrder.ITEM,
item=item_component)
entities.append(item)
def is_blocked(self, x, y):
if self.tiles[x][y].blocked:
return True
return False
def make_map(game_map, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities, colors):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of bounds
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# run through the other rooms and see if intersect
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# no intersection, valid room
# paint room to tiles
create_room(game_map, new_room)
# center coords of new room
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# first room/player start
player.x = new_x
player.y = new_y
else:
# rooms after first
# connect with tunnels
# center coords of prev room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# coin flip
if randint(0, 1) == 1:
# first move horz then vert
create_h_tunnel(game_map, prev_x, new_x, prev_y)
create_v_tunnel(game_map, prev_y, new_y, new_x)
else:
# first ver then horz
create_v_tunnel(game_map, prev_y, new_y, prev_x)
create_h_tunnel(game_map, prev_x, new_x, new_y)
place_entities(new_room, entities, game_map.dungeon_level, colors)
# append room to list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(game_map.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>', (255, 255, 255),
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
# "paint" it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
'>',
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def make_map(game_map, max_rooms, room_min_size, room_max_size, map_width, map_height, player, entities,
max_monsters_per_room, max_items_per_room, colours):
rooms = []
num_rooms = 0
centre_of_last_room_x = None
centre_of_last_room_y = None
for r in range(max_rooms):
# Random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# Random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
new_room = Rect(x, y, w, h)
# Run through the other rooms to see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# This means there are no intersections so this room is valid
# Paint it to the maps tiles
create_room(game_map, new_room)
# Centre coords of the room will be useful later!
(new_x, new_y) = new_room.center()
centre_of_last_room_x = new_x
centre_of_last_room_y = new_y
if num_rooms == 0:
# This is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# All rooms after the first
# connect it to the previous room with a tunnel
# center coords of the previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# Flip a coin
if randint(0, 1) == 1:
# First move horizontally then vertically
create_h_tunnel(game_map, prev_x, new_x, prev_y)
create_v_tunnel(game_map, prev_y, new_y, new_x)
else:
# First move vertically then horizontally
create_v_tunnel(game_map, prev_y, new_y, prev_x)
create_h_tunnel(game_map, prev_x, new_x, new_y)
place_entities(new_room, entities, max_monsters_per_room, max_items_per_room, colours)
# Finally append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(game_map.dungeon_level + 1)
down_stairs = Entity(centre_of_last_room_x, centre_of_last_room_y, '>', (255, 255, 255), 'Stairs',
render_order=RenderOrder.STAIRS, stairs=stairs_component)
entities.append(down_stairs)