def __init__(self, sector, r_factor=0.40, g_factor=0.40, b_factor=0.75, seed=95837203, size=512):
self.seed = randrange(1,10000) if seed is None else seed
self.sector = sector
self.parallax_speed = 0.1
self.starting_left = 0 - self.sector.screen_width/2
self.starting_top = 0 + self.sector.screen_height/2
self.r_factor = r_factor
self.g_factor = g_factor
self.b_factor = b_factor
self.noise_zoom = 2.0
self.noise_octaves = 4.0
self.size = size
self.r_rand = libtcod.random_new_from_seed(self.seed)
self.g_rand = libtcod.random_new_from_seed(self.seed+1)
self.b_rand = libtcod.random_new_from_seed(self.seed+2)
self.c_rand = libtcod.random_new_from_seed(self.seed*2)
self.s_rand = libtcod.random_new_from_seed(self.seed*3)
self.r_noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, self.r_rand)
self.g_noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, self.g_rand)
self.b_noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, self.b_rand)
self.c_noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, self.c_rand)
self.s_noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, self.s_rand)
self.grid = [[None for i in range(self.size)] for i in range(self.size)]
self.last_top = None
self.last_left = None
def render_all():
global color_light_wall
global color_light_ground
map_rng = libtcod.random_new_from_seed(1, algo=libtcod.RNG_MT)
#go through all tiles, and set their background color
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
wall = dungeon_map[x][y].block_sight
if wall:
libtcod.console_put_char_ex(
con, x, y, WALL_CONST, color_dark_wall,
libtcod.light_grey *
libtcod.random_get_float(map_rng, 0.7, 0.8))
else:
libtcod.console_put_char_ex(
con, x, y, FLOOR_CONST, color_dark_ground,
libtcod.dark_grey *
libtcod.random_get_float(map_rng, 0.2, 0.5))
#draw all objects in the list
for obj in objects:
obj.draw()
#blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
new_map.spare_terrain = copy.deepcopy(
new_map.terrain
) # [[0 for y in range(new_map.height)] for x in range(new_map.width)]
dig_ca_region(new_map, algebra.Rect(0, 0, new_map.width, new_map.height),
4, 3)
center = algebra.Location(new_map.width / 2, new_map.height / 2)
stair_loc = _probe_for_stair(new_map, range(new_map.width - 2, center.x,
-1), center.y)
if not stair_loc:
# Uh-oh; no guarantee of completion
print('Recursing with unenterable map:')
# _dump(new_map)
new_map.random_seed = libtcod.random_save(new_map.rng)
return _build_map(new_map)
pool_x = new_map.width / 4
for x in range(pool_x - 6, pool_x + 7):
for y in range(center.y - 6, center.y + 7):
dx = x - pool_x
dy = y - center.y
if math.sqrt(dx**2 + dy**2) > 6:
continue
if new_map.terrain[x][y] == map.TERRAIN_WALL:
new_map.terrain[x][y] = map.TERRAIN_GROUND
new_map.pool_x = pool_x
_scatter_ponds(new_map)
# Can we reach from the stairs to the center of the pool?
_floodfill(new_map, stair_loc.x, stair_loc.y, map.TERRAIN_GROUND,
map.TERRAIN_FLOOR)
if new_map.terrain[pool_x][center.y] != map.TERRAIN_FLOOR:
# Uh-oh; no guarantee of completion
print('Recursing with disconnected map:')
# _dump(new_map)
new_map.random_seed = libtcod.random_save(new_map.rng)
return _build_map(new_map)
# Close up any unconnected subcaves; flood any western bits
for x in range(1, new_map.width - 1):
for y in range(1, new_map.height - 1):
if new_map.terrain[x][y] == map.TERRAIN_GROUND:
new_map.terrain[x][y] = map.TERRAIN_WALL
elif x < pool_x and new_map.terrain[x][y] == map.TERRAIN_FLOOR:
new_map.terrain[x][y] = map.TERRAIN_WATER
#for x in range(0, new_map.width):
# new_map.terrain[x][0] = map.TERRAIN_WALL
# new_map.terrain[x][new_map.height-1] = map.TERRAIN_WALL
#for y in range(0, new_map.height):
# new_map.terrain[0][y] = map.TERRAIN_WALL
# new_map.terrain[new_map.width-1][y] = map.TERRAIN_WALL
return stair_loc
def make_rivers(heightmap, size, seed, river_count=None):
rivers = []
sealevel = -15
random = lt.random_new()
if seed:
random = lt.random_new_from_seed(seed)
if river_count is None:
river_count = lt.random_get_int(random, 10, 15)
mouths = [(0, 0)]
for river in xrange(river_count):
while True:
setting = True
col = lt.random_get_int(random, 0, size - 1)
row = lt.random_get_int(random, 0, size - 1)
if sealevel > lt.heightmap_get_value(heightmap, row, col) >= sealevel - 4:
for mouth in mouths:
if abs(col - mouth[0]) < 5 and abs(row - mouth[1]) < 5:
setting = False
if setting:
mouths.append((col, row))
rivers.append(River(col, row, heightmap, size, random))
break
visualize(rivers, False)
# Clean up inappropriate rivers.
to_remove = set()
i = -1
for river in rivers:
i += 1
if len(river.tiles) < 15:
to_remove.add(i)
if lt.heightmap_get_value(heightmap, river.head_row, river.head_col) < 30:
to_remove.add(i)
for other in rivers:
if river != other:
x = True
for n in list(to_remove):
if other == rivers[n] or river == rivers[n]:
x = False
if x:
for (this_x, this_y) in river.tiles:
for (other_x, other_y) in other.tiles:
distance = ((this_x - other_x) ** 2 + (this_y - other_y) ** 2) ** 0.5
if distance < 2:
to_remove.add(i)
break
remove = sorted(list(to_remove), reverse=True)
for n in remove:
rivers.pop(n)
if len(rivers) > 0:
visualize(heightmap, False)
visualize(rivers)
else:
visualize(heightmap)
return rivers
def spherical_noise(self,
noise_dx=0.0,
noise_dy=0.0,
noise_dz=0.0,
noise_octaves=4.0,
noise_zoom=1.0,
noise_hurst=libtcod.NOISE_DEFAULT_HURST,
noise_lacunarity=libtcod.NOISE_DEFAULT_LACUNARITY,
width=None,
height=None,
seed=None):
self.rnd = libtcod.random_new_from_seed(self.seed) if seed is None else libtcod.random_new_from_seed(seed)
noise = libtcod.noise_new(3, noise_hurst, noise_lacunarity, self.rnd)
hm = libtcod.heightmap_new(width, height)
noise_dx += 0.01
noise_dy += 0.01
noise_dz += 0.01
pi_times_two = 2 * math.pi
pi_div_two = math.pi / 2.0
theta = 0.0
phi = pi_div_two * -1.0
x = 0
y = 0
while phi <= pi_div_two:
while theta <= pi_times_two:
f = [
noise_zoom * math.cos(phi) * math.cos(theta),
noise_zoom * math.cos(phi) * math.sin(theta),
noise_zoom * math.sin(phi),
]
value = libtcod.noise_get_fbm(noise, f, noise_octaves, libtcod.NOISE_PERLIN)
# print((x, y, value))
libtcod.heightmap_set_value(hm, x, y, value)
theta += (pi_times_two / width)
x += 1
phi += (math.pi / (height-1))
y += 1
x = 0
theta = 0.0
return hm
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
new_map.spare_terrain = copy.deepcopy(new_map.terrain) # [[0 for y in range(new_map.height)] for x in range(new_map.width)]
dig_ca_region(new_map, algebra.Rect(0, 0, new_map.width, new_map.height), 4, 3)
center = algebra.Location(new_map.width / 2, new_map.height / 2)
stair_loc = _probe_for_stair(new_map,
range(new_map.width - 2, center.x, -1),
center.y)
if not stair_loc:
# Uh-oh; no guarantee of completion
print('Recursing with unenterable map:')
# _dump(new_map)
new_map.random_seed = libtcod.random_save(new_map.rng)
return _build_map(new_map)
pool_x = new_map.width / 4
for x in range(pool_x - 6, pool_x + 7):
for y in range(center.y - 6, center.y + 7):
dx = x - pool_x
dy = y - center.y
if math.sqrt(dx ** 2 + dy ** 2) > 6:
continue
if new_map.terrain[x][y] == map.TERRAIN_WALL:
new_map.terrain[x][y] = map.TERRAIN_GROUND
new_map.pool_x = pool_x
_scatter_ponds(new_map)
# Can we reach from the stairs to the center of the pool?
_floodfill(new_map, stair_loc.x, stair_loc.y, map.TERRAIN_GROUND, map.TERRAIN_FLOOR)
if new_map.terrain[pool_x][center.y] != map.TERRAIN_FLOOR:
# Uh-oh; no guarantee of completion
print('Recursing with disconnected map:')
# _dump(new_map)
new_map.random_seed = libtcod.random_save(new_map.rng)
return _build_map(new_map)
# Close up any unconnected subcaves; flood any western bits
for x in range(1, new_map.width-1):
for y in range(1, new_map.height-1):
if new_map.terrain[x][y] == map.TERRAIN_GROUND:
new_map.terrain[x][y] = map.TERRAIN_WALL
elif x < pool_x and new_map.terrain[x][y] == map.TERRAIN_FLOOR:
new_map.terrain[x][y] = map.TERRAIN_WATER
#for x in range(0, new_map.width):
# new_map.terrain[x][0] = map.TERRAIN_WALL
# new_map.terrain[x][new_map.height-1] = map.TERRAIN_WALL
#for y in range(0, new_map.height):
# new_map.terrain[0][y] = map.TERRAIN_WALL
# new_map.terrain[new_map.width-1][y] = map.TERRAIN_WALL
return stair_loc
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
num_rooms = 0
for r in range(MAX_ROOMS):
w = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
x = libtcod.random_get_int(new_map.rng, 0, new_map.width - w - 1)
y = libtcod.random_get_int(new_map.rng, 0, new_map.height - h - 1)
new_room = map.Room(x, y, w, h)
failed = False
for other_room in new_map.rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
# There are no intersections, so this room is valid.
_create_room(new_map, new_room)
new_ctr = new_room.center()
if num_rooms > 0:
prev_ctr = new_map.rooms[num_rooms - 1].center()
if libtcod.random_get_int(new_map.rng, 0, 1) == 1:
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x,
prev_ctr.y)
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, new_ctr.x)
else:
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y,
prev_ctr.x)
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, new_ctr.y)
new_map.rooms.append(new_room)
num_rooms += 1
# Create stairs at the center of the last room.
stairs = Object(new_ctr,
'<',
'stairs down',
libtcod.white,
always_visible=True)
stairs.destination = None
stairs.dest_position = None
new_map.objects.insert(0, stairs)
new_map.portals.insert(0, stairs)
def test_random():
rand = libtcodpy.random_get_instance()
rand = libtcodpy.random_new()
libtcodpy.random_delete(rand)
rand = libtcodpy.random_new_from_seed(42)
libtcodpy.random_set_distribution(rand, libtcodpy.DISTRIBUTION_LINEAR)
libtcodpy.random_get_int(rand, 0, 1)
libtcodpy.random_get_int_mean(rand, 0, 1, 0)
libtcodpy.random_get_float(rand, 0, 1)
libtcodpy.random_get_double(rand, 0, 1)
libtcodpy.random_get_float_mean(rand, 0, 1, 0)
libtcodpy.random_get_double_mean(rand, 0, 1, 0)
backup = libtcodpy.random_save(rand)
libtcodpy.random_restore(rand, backup)
libtcodpy.random_delete(rand)
libtcodpy.random_delete(backup)
def load_game():
if not game.savefiles:
contents = ['There are no saved games.']
game.messages.box('Saved games', None, 'center_screenx', 'center_screeny', len(max(contents, key=len)) + 16, len(contents) + 4, contents, input=False, align=libtcod.CENTER)
else:
desc = []
for i in range(len(game.savefiles)):
f = open('saves/' + game.savefiles[i], 'rb')
pl = pickle.load(f)
desc.append(pl.name + ', a level ' + str(pl.level) + ' ' + pl.gender + ' ' + pl.race + ' ' + pl.profession)
f.close()
choice = game.messages.box('Saved games', None, (game.SCREEN_WIDTH - (max(60, len(max(desc, key=len)) + 20))) / 2, ((game.SCREEN_HEIGHT + 1) - max(16, len(desc) + 4)) / 2, max(60, len(max(desc, key=len)) + 20), max(16, len(desc) + 4), desc, step=2, mouse_exit=True)
if choice != -1:
contents = ['Loading.....']
game.messages.box(None, None, 'center_screenx', 'center_screeny', len(max(contents, key=len)) + 16, len(contents) + 4, contents, input=False, align=libtcod.CENTER, nokeypress=True)
f = open('saves/' + game.savefiles[choice], 'rb')
game.player = pickle.load(f)
game.worldmap = pickle.load(f)
game.current_map = pickle.load(f)
game.old_maps = pickle.load(f)
game.message = pickle.load(f)
game.rnd = pickle.load(f)
game.turns = pickle.load(f)
game.gametime = pickle.load(f)
game.fov_torch = pickle.load(f)
game.game_state = pickle.load(f)
game.times_saved = pickle.load(f)
f.close()
fetch_autosave()
game.rnd = libtcod.random_new_from_seed(game.rnd)
game.char = game.current_map.objects[0]
game.worldmap.create_map_images(1)
game.message.empty()
game.message.trim_history()
game.message.new('Welcome back, ' + game.player.name + '!', game.turns, libtcod.Color(96, 212, 238))
if game.current_map.location_id == 0:
util.fetch_border_maps()
util.combine_maps()
game.current_map.check_player_position()
#print game.worldmap.dungeons
return True
return False
def __init__(self, biome, height, width):
self.con = lt.console_new(width, height)
self.area = [[Tile(col, row, ' ') for row in xrange(width)] for col in xrange(height)]
self.random = lt.random_new_from_seed(WORLD_SEED)
self.area, self.fov_map = area_gen.make_area(self.area, biome, 1, self.random)
biomes = {
"cave": {
"fog": lt.Color(20, 10, 15),
"fog density": 0.4, # Lower is more dense
"items": default_cave_items,
"structures": []
},
}
biome = biomes[biome]
self.fog = biome["fog"]
self.fog_density = biome["fog density"]
self.items = biome["items"](self.area)
self.structures = biome["structures"]
def render_all():
global color_light_wall
global color_light_ground
map_rng = libtcod.random_new_from_seed(1, algo=libtcod.RNG_MT)
#go through all tiles, and set their background color
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
wall = dungeon_map[x][y].block_sight
if wall:
libtcod.console_put_char_ex(con, x, y, WALL_CONST, color_dark_wall, libtcod.light_grey * libtcod.random_get_float(map_rng, 0.7, 0.8) )
else:
libtcod.console_put_char_ex(con, x, y, FLOOR_CONST, color_dark_ground, libtcod.dark_grey * libtcod.random_get_float(map_rng, 0.2, 0.5) )
#draw all objects in the list
for obj in objects:
obj.draw()
#blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
num_rooms = 0
for r in range(MAX_ROOMS):
w = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
x = libtcod.random_get_int(new_map.rng, 0, new_map.width - w - 1)
y = libtcod.random_get_int(new_map.rng, 0, new_map.height - h - 1)
new_room = map.Room(x, y, w, h)
failed = False
for other_room in new_map.rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
# There are no intersections, so this room is valid.
_create_room(new_map, new_room)
new_ctr = new_room.center()
if num_rooms > 0:
prev_ctr = new_map.rooms[num_rooms-1].center()
if libtcod.random_get_int(new_map.rng, 0, 1) == 1:
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, prev_ctr.y)
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, new_ctr.x)
else:
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, prev_ctr.x)
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, new_ctr.y)
new_map.rooms.append(new_room)
num_rooms += 1
# Create stairs at the center of the last room.
stairs = Object(new_ctr, '<', 'stairs down', libtcod.white, always_visible=True)
stairs.destination = None
stairs.dest_position = None
new_map.objects.insert(0, stairs)
new_map.portals.insert(0, stairs)
def __init__(self, width, height, seed=54):
self.screen_width = width
self.screen_height = height
self.seed = seed
random.seed(seed)
self.rnd = libtcod.random_new_from_seed(self.seed)
# Load Random Names
self.planet_names = []
with open("planet_names", "r") as planet_names_file:
self.planet_names = planet_names_file.readlines()
random.shuffle(self.planet_names)
self.planet_name_index = -1
# Build Galaxy Map
self.bsp_depth = 6
self.bsp = libtcod.bsp_new_with_size(0, 0, self.screen_width, self.screen_height)
libtcod.bsp_split_recursive(self.bsp, self.rnd, self.bsp_depth, 8, 8, 1.0, 1.0)
# Count number of sectors
count = [ 0 ]
def count_bsp_leaf_nodes(node, userData):
if node.level == self.bsp_depth:
count[0] += 1
return True
libtcod.bsp_traverse_inverted_level_order(self.bsp, count_bsp_leaf_nodes, userData=None)
self.sector_count = count[0]
# self.sector_count = 2**self.bsp_depth # only if we have a fully populated tree (not guaranteed)
self.sectors = []
for i in range(0, self.sector_count):
self.new_sector()
self.link_sectors()
self.current_sector = random.randrange(self.sector_count)
# pp("total sectors: {} current sector: {}".format(self.sector_count, self.current_sector))
self.targeted_sector_index = 0
self.selected_blink = 0
def make_heightmap(size, seed):
# Gradient generated by distance to the northeast corner (creates northeast ocean).
gradient1 = lt.heightmap_new(size, size)
for col in xrange(size):
for row in xrange(size):
distance = ((row - size) ** 2 + col ** 2) ** 0.5
lt.heightmap_set_value(gradient1, row, col, distance)
lt.heightmap_clamp(gradient1, mi=0, ma=WORLD_SIZE)
lt.heightmap_scale(gradient1, 2)
# Similar gradient, but cube root (creates mountains around edge).
gradient2 = lt.heightmap_new(size, size)
for col in xrange(size):
for row in xrange(size):
distance = ((row - size) ** 2 + col ** 2) ** 0.33
lt.heightmap_set_value(gradient2, row, col, distance)
lt.heightmap_clamp(gradient2, mi=0, ma=WORLD_SIZE / 6)
lt.heightmap_scale(gradient2, 5)
# Height map based on Perlin noise.
heightmap = lt.heightmap_new(size, size)
random = lt.random_new()
if seed:
random = lt.random_new_from_seed(seed)
perlin = lt.noise_new(2, h=2, l=2, random=random)
lt.heightmap_add_fbm(heightmap, perlin, mulx=3, muly=3, addx=0, addy=0, octaves=8, delta=50, scale=100)
# Add in gradients.
lt.heightmap_add_hm(heightmap, gradient1, heightmap)
lt.heightmap_add_hm(heightmap, gradient2, heightmap)
lt.heightmap_normalize(heightmap, mi=-100, ma=105)
lt.heightmap_clamp(heightmap, mi=-50, ma=100)
lt.heightmap_normalize(heightmap, mi=-100, ma=100)
visualize(heightmap)
return heightmap
def make_map(player, dungeon_level):
"""
"""
old_map = player.current_map
new_map = map.DungeonMap(MINE_SIZE, MINE_SIZE, dungeon_level)
new_map.objects.append(player)
player.current_map = new_map
player.camera_position = algebra.Location(0, 0)
new_map.random_seed = libtcod.random_save(0)
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
old_quarry_stairs = old_map.quarry_stairs
_link_up_stairs(new_map, old_map, old_quarry_stairs)
_create_entries(new_map, old_quarry_stairs)
_descend_stairs(new_map, player, old_quarry_stairs)
_dig_some_caves(new_map, old_quarry_stairs)
_dig_mine_tunnels(new_map)
map_bounds = algebra.Rect(1, 1, new_map.width-1, new_map.height-1)
for x in range(1, new_map.width-1):
for y in range(1, new_map.height-1):
if libtcod.random_get_float(new_map.rng, 0., 1.) < 0.2:
new_map.terrain[x][y] = map.TERRAIN_GROUND
ca_cartographer._generation(new_map, map_bounds, 7, 1)
ca_cartographer._generation(new_map, map_bounds, 5, 1)
# Redig the initial rooms because the CA can fill in the stairs
for i in range(3):
_create_room(new_map, new_map.rooms[i])
for i in range(3):
stair_pos = old_quarry_stairs[i].dest_position
ca_cartographer._floodfill(new_map, stair_pos.x, stair_pos.y,
map.TERRAIN_GROUND, map.TERRAIN_FLOOR)
for x in range(1, new_map.width-1):
for y in range(1, new_map.height-1):
if new_map.terrain[x][y] == map.TERRAIN_GROUND:
new_map.terrain[x][y] = map.TERRAIN_WALL
#for x in range(0, new_map.width):
# new_map.terrain[x][0] = map.TERRAIN_WALL
# new_map.terrain[x][new_map.height-1] = map.TERRAIN_WALL
#for y in range(0, new_map.height):
# new_map.terrain[0][y] = map.TERRAIN_WALL
# new_map.terrain[new_map.width-1][y] = map.TERRAIN_WALL
zone_divisor = MINE_SIZE / 3
slime_zone = new_map.rnd(0, 2)
while True:
undead_zone = new_map.rnd(0, 2)
if undead_zone != slime_zone:
break
for r in range(3, len(new_map.rooms)):
if new_map.rnd(1, 4) < 3:
room = new_map.rooms[r]
zone = room.center().x / zone_divisor
if zone == slime_zone:
if new_map.rnd(1, 2) == 1:
bestiary.slime(new_map, _find_floor_near_room(new_map, room), player)
bestiary.slime(new_map, _find_floor_near_room(new_map, room), player)
else:
bestiary.jelly(new_map, _find_floor_near_room(new_map, room), player)
elif zone == undead_zone:
bestiary.ghul(new_map, _find_floor_near_room(new_map, room), player)
else:
bestiary.worm(new_map, _find_floor_near_room(new_map, room), player)
r = new_map.rnd(3, len(new_map.rooms) - 1)
pos = new_map.rooms[r].center()
while new_map.is_blocked_at(pos):
pos += actions.random_direction()
new_map.objects.insert(0, Object(pos, '%', "hero's corpse", libtcod.dark_red))
sword = miscellany.the_black_sword()
sword.pos = pos
new_map.objects.insert(0, sword)
new_map.initialize_fov()
new_map.xp_visit = _dungeon_exploration
return False # Don't need to generate stairs in caller thanks to _link_up_stairs()
#size of the map
MAP_WIDTH = 80
MAP_HEIGHT = 45
#map constants
WALL_CONST = '#'
FLOOR_CONST = '.'
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
LIMIT_FPS = 20 #20 frames-per-second maximum
#create random number generator
rng = libtcod.random_new_from_seed(1, algo=libtcod.RNG_MT)
color_dark_wall = libtcod.lightest_grey
color_dark_ground = libtcod.lightest_grey
class Rect:
#a rectangle on the map. used to characterize a room.
def __init__(self, x, y, w, h):
self.x1 = x
self.y1 = y
self.x2 = x + w
self.y2 = y + h
def center(self):
center_x = (self.x1 + self.x2) / 2
center_y = (self.y1 + self.y2) / 2
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
print('Seeding regions')
for u in range(config.OUTDOOR_MAP_WIDTH / 10):
for v in range(config.OUTDOOR_MAP_HEIGHT / 10):
x = libtcod.random_get_int(new_map.rng, 0, 9) + u * 10
y = libtcod.random_get_int(new_map.rng, 0, 9) + v * 10
new_map.region_seeds.append([x, y])
print('Growing the world-tree')
region_tree = scipy.spatial.KDTree(new_map.region_seeds)
new_map.region_terrain = [None for i in range(len(new_map.region_seeds))]
new_map.region_elevations = [-1 for r in range(len(new_map.region_seeds))]
new_map.region_entered = [False for i in range(len(new_map.region_seeds))]
new_map.elevation_visited = [False for i in range(0, 10)]
print('Assigning regions')
for x in range(config.OUTDOOR_MAP_WIDTH):
for y in range(config.OUTDOOR_MAP_HEIGHT):
(d, i) = region_tree.query([[x, y]])
new_map.region[x][y] = i[0]
new_map.terrain[x][y] = map.TERRAIN_GROUND
peak = [
libtcod.random_get_int(new_map.rng,
int(config.OUTDOOR_MAP_WIDTH * .35),
int(config.OUTDOOR_MAP_WIDTH * .65)),
libtcod.random_get_int(new_map.rng,
int(config.OUTDOOR_MAP_WIDTH * .35),
int(config.OUTDOOR_MAP_WIDTH * .65))
]
print('The peak is at ' + str(peak[0]) + ', ' + str(peak[1]))
for r in range(20):
new_map.region_elevations[r] = 0
new_map.region_elevations[380 + r] = 0
new_map.region_elevations[r * 20] = 0
new_map.region_elevations[r * 20 + 19] = 0
(d, peak_regions) = region_tree.query([peak], 3)
for p in peak_regions[0]:
new_map.region_elevations[p] = 9
_interpolate_heights(new_map, peak)
_ensure_penultimate_height(new_map, peak, region_tree)
_extend_hills(new_map, peak)
_debug_region_heights(new_map)
_clump_terrain(new_map)
_place_seaside_height(new_map)
# TODO: level_desert() here to guarantee caravanserai is in the northeast
# TODO: sink_quarry() here before we _mark_slopes
# to get rid of messy after-the-fact slope fixup in dig_quarry()
strata = _find_terrain_types(new_map)
_debug_region_terrain(new_map)
_mark_slopes(new_map)
_assign_terrain(new_map)
_make_rotunda(new_map, peak)
compound_cartographer.make_caravanserai(new_map)
_dig_quarry(new_map, peak)
_make_grotto(new_map)
_site_final_dungeon(new_map, strata)
new_map.peak = peak
#create world
nwidth = 100
nheight = 60
alivechar = '+'
deadchar = ' '
char_option = 'ascii'
speed = .1
inc = 0.01
# default generator
default = libtcod.random_get_instance()
# another random generator
my_random = libtcod.random_new()
# a random generator with a specific seed
my_determinist_random = libtcod.random_new_from_seed(0xdeadbeef)
world = World(nwidth, nheight, alivechar, deadchar, char_option,
my_determinist_random)
libtcod.console_set_custom_font(
'oryx_tiles3.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD,
32, 12)
libtcod.console_init_root(nwidth, nheight, 'johnstein\'s Game of RogueLife!',
False, libtcod.RENDERER_SDL)
libtcod.sys_set_fps(30)
libtcod.console_map_ascii_codes_to_font(256, 32, 0,
5) #map all characters in 1st row
libtcod.console_map_ascii_codes_to_font(256 + 32, 32, 0,
6) #map all characters in 2nd row
def make_final_map(player, dungeon_level):
"""
"""
old_map = player.current_map
new_map = map.DungeonMap(FINAL_DUNGEON_SIZE, FINAL_DUNGEON_SIZE, dungeon_level)
new_map.objects.append(player)
player.current_map = new_map
player.camera_position = algebra.Location(0, 0)
new_map.random_seed = libtcod.random_save(0)
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
entry_stairs = old_map.dungeon_stairs
mine_cartographer._link_up_stairs(new_map, old_map, entry_stairs)
mine_cartographer._create_entries(new_map, entry_stairs)
mine_cartographer._descend_stairs(new_map, player, entry_stairs)
num_rooms = 3
for r in range(3, MAX_ROOMS):
w = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
x = libtcod.random_get_int(new_map.rng, 0, new_map.width - w - 1)
y = libtcod.random_get_int(new_map.rng, 0, new_map.height - h - 1)
new_room = map.Room(x, y, w, h)
failed = False
for other_room in new_map.rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
# There are no intersections, so this room is valid.
_create_room(new_map, new_room, num_rooms)
new_ctr = new_room.center()
prev_ctr = new_map.rooms[num_rooms-3].center()
if libtcod.random_get_int(new_map.rng, 0, 1) == 1:
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, prev_ctr.y)
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, new_ctr.x)
else:
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, prev_ctr.x)
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, new_ctr.y)
new_map.rooms.append(new_room)
new_map.room_entered.append(False)
num_rooms += 1
# TODO: should be floodfill from one stair, make *sure* the other two are
# connected
for i in range(3):
stair_pos = entry_stairs[i].dest_position
ca_cartographer._floodfill(new_map, stair_pos.x, stair_pos.y,
map.TERRAIN_GROUND, map.TERRAIN_FLOOR)
_add_doors(new_map)
for i in range(3, num_rooms - 1):
if (new_map.rnd(1, 2) == 1):
foe = bestiary.dvergr(new_map, new_map.rooms[i].center(), player)
_new_equipment(foe, miscellany.handaxe())
_new_equipment(foe, miscellany.roundshield())
if new_map.rnd(1, 2) == 1:
_new_item(foe, miscellany.bandage(1))
if new_map.rnd(1, 2) == 1:
_new_item(foe, miscellany.kumiss(1))
foe = bestiary.tepegoz(new_map, new_ctr, player)
_new_equipment(foe, miscellany.maguffin())
_new_equipment(foe, miscellany.spear())
_new_equipment(foe, miscellany.roundshield())
new_map.initialize_fov()
new_map.xp_visit = _dungeon_exploration
return False # Don't need to generate stairs in caller thanks to _link_up_stairs()
#size of the map
MAP_WIDTH = 80
MAP_HEIGHT = 45
#map constants
WALL_CONST = '#'
FLOOR_CONST = '.'
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
LIMIT_FPS = 20 #20 frames-per-second maximum
#create random number generator
rng = libtcod.random_new_from_seed(1, algo=libtcod.RNG_MT)
color_dark_wall = libtcod.lightest_grey
color_dark_ground = libtcod.lightest_grey
class Rect:
#a rectangle on the map. used to characterize a room.
def __init__(self, x, y, w, h):
self.x1 = x
self.y1 = y
self.x2 = x + w
self.y2 = y + h
def center(self):
center_x = (self.x1 + self.x2) / 2
def __init__(self, seed=12271990):
self.rnd = libtcod.random_new_from_seed(seed, algo=libtcod.RNG_MT)
def _build_map(new_map):
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
print('Seeding regions')
for u in range(config.OUTDOOR_MAP_WIDTH / 10):
for v in range(config.OUTDOOR_MAP_HEIGHT / 10):
x = libtcod.random_get_int(new_map.rng, 0, 9) + u * 10
y = libtcod.random_get_int(new_map.rng, 0, 9) + v * 10
new_map.region_seeds.append([x, y])
print('Growing the world-tree')
region_tree = scipy.spatial.KDTree(new_map.region_seeds)
new_map.region_terrain = [None for i in range(len(new_map.region_seeds))]
new_map.region_elevations = [-1 for r in range(len(new_map.region_seeds))]
new_map.region_entered = [False for i in range(len(new_map.region_seeds))]
new_map.elevation_visited = [False for i in range(0,10)]
print('Assigning regions')
for x in range(config.OUTDOOR_MAP_WIDTH):
for y in range(config.OUTDOOR_MAP_HEIGHT):
(d, i) = region_tree.query([[x, y]])
new_map.region[x][y] = i[0]
new_map.terrain[x][y] = map.TERRAIN_GROUND
peak = [libtcod.random_get_int(new_map.rng, int(config.OUTDOOR_MAP_WIDTH * .35), int(config.OUTDOOR_MAP_WIDTH * .65)),
libtcod.random_get_int(new_map.rng, int(config.OUTDOOR_MAP_WIDTH * .35), int(config.OUTDOOR_MAP_WIDTH * .65))]
print('The peak is at ' + str(peak[0]) + ', ' + str(peak[1]))
for r in range(20):
new_map.region_elevations[r] = 0
new_map.region_elevations[380+r] = 0
new_map.region_elevations[r*20] = 0
new_map.region_elevations[r*20+19] = 0
(d, peak_regions) = region_tree.query([peak], 3)
for p in peak_regions[0]:
new_map.region_elevations[p] = 9
_interpolate_heights(new_map, peak)
_ensure_penultimate_height(new_map, peak, region_tree)
_extend_hills(new_map, peak)
_debug_region_heights(new_map)
_clump_terrain(new_map)
_place_seaside_height(new_map)
# TODO: level_desert() here to guarantee caravanserai is in the northeast
# TODO: sink_quarry() here before we _mark_slopes
# to get rid of messy after-the-fact slope fixup in dig_quarry()
strata = _find_terrain_types(new_map)
_debug_region_terrain(new_map)
_mark_slopes(new_map)
_assign_terrain(new_map)
_make_rotunda(new_map, peak)
compound_cartographer.make_caravanserai(new_map)
_dig_quarry(new_map, peak)
_make_grotto(new_map)
_site_final_dungeon(new_map, strata)
new_map.peak = peak
#create world
nwidth = 100
nheight = 60
alivechar = '+'
deadchar = ' '
char_option = 'ascii'
speed = .1
inc = 0.01
# default generator
default = libtcod.random_get_instance()
# another random generator
my_random = libtcod.random_new()
# a random generator with a specific seed
my_determinist_random = libtcod.random_new_from_seed(0xdeadbeef)
world = World(nwidth,nheight, alivechar, deadchar, char_option, my_determinist_random)
libtcod.console_set_custom_font('oryx_tiles3.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD, 32, 12)
libtcod.console_init_root(nwidth, nheight, 'johnstein\'s Game of RogueLife!', False, libtcod.RENDERER_SDL)
libtcod.sys_set_fps(30)
libtcod.console_map_ascii_codes_to_font(256 , 32, 0, 5) #map all characters in 1st row
libtcod.console_map_ascii_codes_to_font(256+32, 32, 0, 6) #map all characters in 2nd row
mouse = libtcod.Mouse()
key = libtcod.Key()
#initialize population
def make_map(player, dungeon_level):
"""
"""
old_map = player.current_map
new_map = map.DungeonMap(MINE_SIZE, MINE_SIZE, dungeon_level)
new_map.objects.append(player)
player.current_map = new_map
player.camera_position = algebra.Location(0, 0)
new_map.random_seed = libtcod.random_save(0)
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
old_quarry_stairs = old_map.quarry_stairs
_link_up_stairs(new_map, old_map, old_quarry_stairs)
_create_entries(new_map, old_quarry_stairs)
_descend_stairs(new_map, player, old_quarry_stairs)
_dig_some_caves(new_map, old_quarry_stairs)
_dig_mine_tunnels(new_map)
map_bounds = algebra.Rect(1, 1, new_map.width - 1, new_map.height - 1)
for x in range(1, new_map.width - 1):
for y in range(1, new_map.height - 1):
if libtcod.random_get_float(new_map.rng, 0., 1.) < 0.2:
new_map.terrain[x][y] = map.TERRAIN_GROUND
ca_cartographer._generation(new_map, map_bounds, 7, 1)
ca_cartographer._generation(new_map, map_bounds, 5, 1)
# Redig the initial rooms because the CA can fill in the stairs
for i in range(3):
_create_room(new_map, new_map.rooms[i])
for i in range(3):
stair_pos = old_quarry_stairs[i].dest_position
ca_cartographer._floodfill(new_map, stair_pos.x, stair_pos.y,
map.TERRAIN_GROUND, map.TERRAIN_FLOOR)
for x in range(1, new_map.width - 1):
for y in range(1, new_map.height - 1):
if new_map.terrain[x][y] == map.TERRAIN_GROUND:
new_map.terrain[x][y] = map.TERRAIN_WALL
#for x in range(0, new_map.width):
# new_map.terrain[x][0] = map.TERRAIN_WALL
# new_map.terrain[x][new_map.height-1] = map.TERRAIN_WALL
#for y in range(0, new_map.height):
# new_map.terrain[0][y] = map.TERRAIN_WALL
# new_map.terrain[new_map.width-1][y] = map.TERRAIN_WALL
zone_divisor = MINE_SIZE / 3
slime_zone = new_map.rnd(0, 2)
while True:
undead_zone = new_map.rnd(0, 2)
if undead_zone != slime_zone:
break
for r in range(3, len(new_map.rooms)):
if new_map.rnd(1, 4) < 3:
room = new_map.rooms[r]
zone = room.center().x / zone_divisor
if zone == slime_zone:
if new_map.rnd(1, 2) == 1:
bestiary.slime(new_map,
_find_floor_near_room(new_map,
room), player)
bestiary.slime(new_map,
_find_floor_near_room(new_map,
room), player)
else:
bestiary.jelly(new_map,
_find_floor_near_room(new_map,
room), player)
elif zone == undead_zone:
bestiary.ghul(new_map, _find_floor_near_room(new_map, room),
player)
else:
bestiary.worm(new_map, _find_floor_near_room(new_map, room),
player)
r = new_map.rnd(3, len(new_map.rooms) - 1)
pos = new_map.rooms[r].center()
while new_map.is_blocked_at(pos):
pos += actions.random_direction()
new_map.objects.insert(0,
Object(pos, '%', "hero's corpse", libtcod.dark_red))
sword = miscellany.the_black_sword()
sword.pos = pos
new_map.objects.insert(0, sword)
new_map.initialize_fov()
new_map.xp_visit = _dungeon_exploration
return False # Don't need to generate stairs in caller thanks to _link_up_stairs()
def make_final_map(player, dungeon_level):
"""
"""
old_map = player.current_map
new_map = map.DungeonMap(FINAL_DUNGEON_SIZE, FINAL_DUNGEON_SIZE,
dungeon_level)
new_map.objects.append(player)
player.current_map = new_map
player.camera_position = algebra.Location(0, 0)
new_map.random_seed = libtcod.random_save(0)
new_map.rng = libtcod.random_new_from_seed(new_map.random_seed)
entry_stairs = old_map.dungeon_stairs
mine_cartographer._link_up_stairs(new_map, old_map, entry_stairs)
mine_cartographer._create_entries(new_map, entry_stairs)
mine_cartographer._descend_stairs(new_map, player, entry_stairs)
num_rooms = 3
for r in range(3, MAX_ROOMS):
w = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
h = libtcod.random_get_int(new_map.rng, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
x = libtcod.random_get_int(new_map.rng, 0, new_map.width - w - 1)
y = libtcod.random_get_int(new_map.rng, 0, new_map.height - h - 1)
new_room = map.Room(x, y, w, h)
failed = False
for other_room in new_map.rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
# There are no intersections, so this room is valid.
_create_room(new_map, new_room, num_rooms)
new_ctr = new_room.center()
prev_ctr = new_map.rooms[num_rooms - 3].center()
if libtcod.random_get_int(new_map.rng, 0, 1) == 1:
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, prev_ctr.y)
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, new_ctr.x)
else:
_create_v_tunnel(new_map, prev_ctr.y, new_ctr.y, prev_ctr.x)
_create_h_tunnel(new_map, prev_ctr.x, new_ctr.x, new_ctr.y)
new_map.rooms.append(new_room)
new_map.room_entered.append(False)
num_rooms += 1
# TODO: should be floodfill from one stair, make *sure* the other two are
# connected
for i in range(3):
stair_pos = entry_stairs[i].dest_position
ca_cartographer._floodfill(new_map, stair_pos.x, stair_pos.y,
map.TERRAIN_GROUND, map.TERRAIN_FLOOR)
_add_doors(new_map)
for i in range(3, num_rooms - 1):
if (new_map.rnd(1, 2) == 1):
foe = bestiary.dvergr(new_map, new_map.rooms[i].center(), player)
_new_equipment(foe, miscellany.handaxe())
_new_equipment(foe, miscellany.roundshield())
if new_map.rnd(1, 2) == 1:
_new_item(foe, miscellany.bandage(1))
if new_map.rnd(1, 2) == 1:
_new_item(foe, miscellany.kumiss(1))
foe = bestiary.tepegoz(new_map, new_ctr, player)
_new_equipment(foe, miscellany.maguffin())
_new_equipment(foe, miscellany.spear())
_new_equipment(foe, miscellany.roundshield())
new_map.initialize_fov()
new_map.xp_visit = _dungeon_exploration
return False # Don't need to generate stairs in caller thanks to _link_up_stairs()
