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 __init__(self, mapsize, resources):
self.world_width = mapsize
self.world_height = self.world_width / 2
self.grid = []
self.world_noise = libtcod.noise_new(3)
self.resource_noise = libtcod.noise_new(3)
self.name = 'map_name'
for x in xrange(self.world_width):
row = []
for y in xrange(self.world_height):
row.append(
GridCoordinate(x, y, self.world_width, self.world_height,
self.world_noise, self.resource_noise))
self.grid.append(row)
libtcod.noise_delete(self.world_noise)
libtcod.noise_delete(self.resource_noise)
for x in xrange(self.world_width):
for y in xrange(self.world_height):
self.grid[x][y].neighbors = get_neighbors(self, x, y)
# Spawn resource nodes where the resource density is sufficiently high
for x in xrange(self.world_width):
for y in xrange(self.world_height):
if self.grid[x][y].resource_density > self.RESOURCE_THRESHHOLD:
new_node = ResourceNode(x, y, resources)
print x, y
# Pathfinding graph for all land tiles; remove sea tiles and delete
# neighbor, cost entry in the neighbors list
self.land_graph = self.grid
for x in xrange(self.world_width):
for y in xrange(self.world_height):
cell = self.land_graph[x][y]
if cell.elevation >= 0:
cell.neighbors = {}
for key in cell.neighbors.copy():
if key.elevation >= 0:
if key in cell.neighbors:
del cell.neighbors[key]
# Pathfinding graph for all sea tiles
self.sea_graph = self.grid
for x in xrange(self.world_width):
for y in xrange(self.world_height):
cell = self.sea_graph[x][y]
if cell.elevation > 0:
cell.neighbors = {}
for key in cell.neighbors.copy():
if key.elevation > 0:
if key in cell.neighbors:
del cell.neighbors[key]
def generate(self):
print 'Starting world map generation....'
t0 = libtcod.sys_elapsed_seconds()
accepted = False
world = 1
while not accepted:
print 'World #' + str(world) + '....'
self.noise = libtcod.noise_new(2, self.rnd)
libtcod.noise_set_type(self.noise, libtcod.NOISE_PERLIN)
game.heightmap = libtcod.heightmap_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT)
#game.precipitation = libtcod.heightmap_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT)
#game.temperature = libtcod.heightmap_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT)
#game.biome = libtcod.heightmap_new(game.WORLDMAP_WIDTH, game.WORLDMAP_HEIGHT)
self.add_landmass()
self.smooth_edges()
self.set_landmass(self.randomize('float', 0.30, 0.45, 3), self.sandheight)
self.add_rivers()
self.create_map_images()
self.place_dungeons()
accepted = self.analyse_world()
world += 1
print '-------------'
t1 = libtcod.sys_elapsed_seconds()
print 'World map generation finished.... (%.3f seconds)' % (t1 - t0)
def test_noise():
noise = libtcodpy.noise_new(1)
libtcodpy.noise_set_type(noise, libtcodpy.NOISE_SIMPLEX)
libtcodpy.noise_get(noise, [0])
libtcodpy.noise_get_fbm(noise, [0], 4)
libtcodpy.noise_get_turbulence(noise, [0], 4)
libtcodpy.noise_delete(noise)
def generate(self, empty=False):
default_block_tiles = {'Dungeon': 'wall', 'Cave': 'cavern wall', 'Maze': 'wall', 'Mountain Peak': 'high mountains', 'Mountains': 'mountains', 'High Hills': 'hills', 'Low Hills': 'medium grass', 'Forest': 'grass', 'Plains': 'grass', 'Coast': 'sand', 'Shore': 'shallow water', 'Sea': 'deep water', 'Ocean': 'very deep water'}
self.objects = [game.char]
self.tile = [[{} for y in range(self.map_height)] for x in range(self.map_width)]
if not empty:
for x in range(self.map_width):
for y in range(self.map_height):
self.set_tile_values(default_block_tiles[self.type], x, y, reset=False)
game.fov_noise = libtcod.noise_new(1, 1.0, 1.0)
game.fov_torchx = 0.0
success = False
if not empty:
if self.type == 'Dungeon':
rooms = self.create_dungeon()
self.place_doors()
self.place_objects()
self.place_traps('floor')
self.place_stairs(rooms)
elif self.type == 'Cave':
while not success:
success = self.create_cave_maze('cave', 'dirt', 'cavern wall', 55, True)
self.place_objects()
self.place_traps('dirt')
self.add_stalagmites()
elif self.type == 'Maze':
while not success:
success = self.create_cave_maze('maze', 'floor', 'wall', 45, False)
self.place_objects()
self.place_traps('floor')
else:
self.create_outdoor_map(default_block_tiles[self.type])
self.place_objects()
def __init__(self):
global debug, font_width, font_height, con, panel, ps, fov_noise, savefiles, baseitems, prefix, suffix, tiles, monsters
IO.load_settings()
debug = dbg.Debug()
debug.enable = True
for key, value in fonts.items():
if setting_font == key:
libtcod.console_set_custom_font(value['file'], libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
font_width = value['width']
font_height = value['height']
self.init_root_console()
#libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'Immortal ' + VERSION, False)
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = libtcod.console_new(MESSAGE_WIDTH, MESSAGE_HEIGHT)
ps = libtcod.console_new(PLAYER_STATS_WIDTH, PLAYER_STATS_HEIGHT)
fov_noise = libtcod.noise_new(1, 1.0, 1.0)
savefiles = [f for f in os.listdir('saves') if os.path.isfile(os.path.join('saves', f))]
IO.load_high_scores()
baseitems = BaseItemList()
baseitems.init_parser()
prefix = PrefixList()
prefix.init_parser()
suffix = SuffixList()
suffix.init_parser()
tiles = mapgen.TileList()
tiles.init_parser()
monsters = MonsterList()
monsters.init_parser()
self.main_menu()
def generateWater(self):
#noise_octaves = 4.0
noise_zoom = 2.0
noise_hurst = libtcod.NOISE_DEFAULT_HURST
noise_lacunarity = libtcod.NOISE_DEFAULT_LACUNARITY
mapped = self.mappedArea
noise = libtcod.noise_new(2, noise_hurst, noise_lacunarity)
for y in range(self.height):
for x in range(self.width):
f = [noise_zoom * x / (self.width), noise_zoom * y / (self.height)]
noisefloat = libtcod.noise_get(noise, f, libtcod.NOISE_PERLIN)
if noisefloat >= float(0) and noisefloat <= 0.1:
mapped[x][y].tileType = "water"
mapped[x][y].blocked = False
mapped[x][y].block_sight = False
mapped[x][y].slows = True
#Block the edges of the map so player can't crash the game
for y in range(self.height):
#mapped[0][y].tileType = None
mapped[0][y].blocked = True
mapped[self.width-1][y].blocked = True
for x in range(self.width):
mapped[x][0].blocked = True
mapped[x][self.height-1].blocked = True
def add_noise(self):
libtcod.heightmap_normalize(self.hm, 0, 1)
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.noise_set_type(self.noise, libtcod.NOISE_PERLIN)
libtcod.heightmap_add_fbm(self.hm, self.noise, 1, 1, 1, 1, 8, 0.5, 0.5)
libtcod.heightmap_normalize(self.hm, 0, 255)
def create():
display.create_surface('background')
display.create_surface('text')
display.blit_background('background')
roll()
NOISE = tcod.noise_new(2, h=tcod.NOISE_DEFAULT_HURST, random=tcod.random_new())
for y in range(0, constants.WINDOW_HEIGHT):
for x in range(0, constants.WINDOW_WIDTH):
_noise_values = [(ZOOM * x / (constants.WINDOW_WIDTH)),
(ZOOM * y / (constants.WINDOW_HEIGHT))]
_height = 1 - tcod.noise_get_turbulence(NOISE, _noise_values, tcod.NOISE_SIMPLEX)
_dist_to_crosshair = 30
_crosshair_mod = abs((_dist_to_crosshair - 1))
if _height > .4:
_height = (_height - .4) / .4
_r, _g, _b = numbers.clip(30 * _height, 20, 255), 50 * _height, numbers.clip(30 * _height, 30, 255)
else:
_r, _g, _b = 20, 0, 30
_r += 30# * _crosshair_mod
if x < SIDEBAR_WIDTH:
if y < 7:
_r = numbers.interp(_r, .0, .4)
_g = numbers.interp(_g, .0, .4)
_b = numbers.interp(_b, .0, .4)
elif y < 43:
_r = numbers.interp(_r, .0, .6)
_g = numbers.interp(_g, .0, .6)
_b = numbers.interp(_b, .0, .6)
elif y < constants.WINDOW_HEIGHT:
_r = numbers.interp(_r, 1, .7)
_g = numbers.interp(_g, 1, .7)
_b = numbers.interp(_b, 1, .7)
else:
_r = (int(round(_r * 1.0)))
_g = (int(round(_g * .2)))
_b = (int(round(_b * .2)))
if x > SIDEBAR_WIDTH + 3 and x < constants.WINDOW_WIDTH - 6:
if y > 18 and y < 36:
_r = numbers.interp(_r, 255, .1)
_g = numbers.interp(_g, 255, .1)
_b = numbers.interp(_b, 255, .1)
if x > SIDEBAR_WIDTH + 3 and x < constants.WINDOW_WIDTH - 6:
if y > 10 and y < 16:
_r = numbers.interp(_r, .0, .4)
_g = numbers.interp(_g, .0, .4)
_b = numbers.interp(_b, .0, .4)
display._set_char('background', x, y, ' ', (0, 0, 0), (_r, _g, _b))
def make_map():
global map, objects
#the list of objects with just the player
objects = [player]
player.x = MAP_WIDTH / 2
player.y = MAP_HEIGHT / 2
myrng = libtcod.random_new(123)
noise2d = libtcod.noise_new(2,libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY, myrng)
libtcod.noise_set_type(noise2d, libtcod.NOISE_PERLIN)
#fill map with "normal" tiles
map = [[Tile(False, libtcod.light_gray)
for y in range(MAP_HEIGHT)]
for x in range(MAP_WIDTH)]
#add color
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
value = int((libtcod.noise_get_fbm(noise2d,[x/float(MAP_WIDTH),y/float(MAP_HEIGHT)],32) + 1) * 96 )
map[x][y] = Tile(False, libtcod.Color(value,value,value))
r = [libtcod.random_get_int(0, CRATER_MIN_SIZE, (CRATER_MIN_SIZE + (CRATER_MAX_SIZE - CRATER_MIN_SIZE) * (MAX_CRATERS - i)**2/(MAX_CRATERS**2)) ) for i in range(MAX_CRATERS)]
r.sort(reverse=True)
for i in range(MAX_CRATERS):
x = libtcod.random_get_int(0, 0, MAP_WIDTH - 1)
y = libtcod.random_get_int(0, 0, MAP_HEIGHT - 1)
# r = libtcod.random_get_int(0, CRATER_MIN_SIZE, (CRATER_MIN_SIZE + (CRATER_MAX_SIZE - CRATER_MIN_SIZE) * (MAX_CRATERS - i)/MAX_CRATERS) )
make_crater(x, y, r[i])
spawn_silicon(noise2d)
def noise_example(): noise1d = libtcod.noise_new(1) for s in range(10): x = s / float(5) v = libtcod.noise_get(noise1d, [x]) print(v) libtcod.noise_delete(noise1d)
def create(self): w=self.width=cfg.OW_WIDTH h=self.height=cfg.OW_HEIGHT th=cfg.OW_TREE_THRES self.level=[[OverworldTile(j,i) for i in xrange(h)] for j in xrange(w)] self.console=libtcod.console_new(w,h) backColor=libtcod.Color(0, 0, 0) noise2d = libtcod.noise_new(2) for x in xrange(w): for y in xrange(h): zoom=0.09 f = [zoom * x,zoom * y] val = libtcod.noise_get(noise2d,f) c1=int((((val*-1)+1)/2)*30) c2=10+int(((val+1)/2)*20) if val>th: self.level[x][y].setChar(23) self.level[x][y].setColors(libtcod.Color(0, 200, 0),libtcod.Color(0, 0, 0)) self.level[x][y].setBlocked(True) else: self.level[x][y].setChar(176) self.level[x][y].setColors(libtcod.Color(0, c1, 0),libtcod.Color(0, c2, 0)) while len(self.pathable)<400: self.findPathable() self.clearUnpathableAreas() #self.findPathable() # Now a final scan for the full area # Place town town_pos=random.choice(self.pathable) town=OverworldTileEntity(town_pos[0],town_pos[1]) town.setColors(libtcod.Color(0, 100, 150),libtcod.Color(40, 40, 0)) self.tile_entity.append(town) self.town=town # Place dungeons for i in xrange(cfg.DUNGEONS): validLocation=False pos=None while not validLocation: validLocation=True pos=random.choice(self.pathable) for entity in self.tile_entity: if entity.position()==pos: validLocation=False dungeon=OverworldTileEntity(pos[0],pos[1]) dungeon.setColors(libtcod.Color(200, 0, 0),libtcod.Color(40, 0, 0)) self.tile_entity.append(dungeon) self.buildBlockedMap()
def create():
global NOISE
display.create_surface("background")
NOISE = tcod.noise_new(2, h=tcod.NOISE_DEFAULT_HURST, random=tcod.random_new())
paint_map(initial=True)
def noise_2d(width, height):
noise = libtcod.noise_new(2)
noise_map = {}
for x in range(width):
for y in range(height):
value = libtcod.noise_get(noise, [x * 0.06, y * 0.06])
noise_map[(x, y)] = value * 100
return noise_map
def __init__(self, w, h):
global TROPICS_THRESHOLD, TEMPERATE_THRESHOLD, TAIGA_THRESHOLD
self.w = w
self.h = h
self.equator = h/2
TROPICS_THRESHOLD = (self.equator/2)/3
TEMPERATE_THRESHOLD = self.equator/2
TAIGA_THRESHOLD = self.equator - self.equator*0.1
self.tiles = [[ Tile(ix,iy, False, map_tile=True)
for iy in range(h) ]
for ix in range(w)]
x,y = 0,0
self.traffic = [[0
for y in range(h)]
for x in range(w)]
#this holds the *colour* value of the tiles temps.
self.temperature_map = [[0
for y in range(h)]
for x in range(w)]
self.moisture_map = [[0
for y in range(h)]
for x in range(w)]
self.hm = libtcod.heightmap_new(self.w, self.h)
self.hm2 = libtcod.heightmap_new(self.w, self.h)
self.hm3 = libtcod.heightmap_new(self.w, self.h)
self.generate_land(self.hm)
self.generate_land(self.hm2)
self.generate_land(self.hm3)
libtcod.noise_set_type(self.noise, libtcod.NOISE_SIMPLEX)
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
self.multiply_noise()
self.multiply_noise()
libtcod.heightmap_normalize(self.hm, 0, 255)
#libtcod.heightmap_normalize(self.hm2, 0, 255)
#libtcod.heightmap_normalize(self.hm3, 0, 255)
#libtcod.heightmap_rain_erosion(self.hm, (self.w + self.h)*4, 0.5, 0.1, None)
self.add_noise()
self.turn_to_tiles()
self.determine_temperatures()
self.normalise_temperatures()
self.wind_gen = Particle_Map(self,1500)
self.generate_mini_map(10)
self.cities = []
self.dungeons = []
self.generate_city(libtcod.random_get_int(0, 4, 10))
self.generate_dungeons(10)
def create():
global NOISE
display.create_surface('background')
NOISE = tcod.noise_new(2,
h=tcod.NOISE_DEFAULT_HURST,
random=tcod.random_new())
paint_map(initial=True)
def generate(self, border_size = 1, air_buffer = 10):
noise_2d = libtcod.noise_new(2)
self.tiles = [[ Dirt(libtcod.noise_get(noise_2d,[x,y])*3) for y in range(self.height) ] for x in range(self.width) ]
for x in range(self.width):
for y in range(self.height):
if x < border_size or y < border_size or x > ((self.width - 1) - border_size) or y > ((self.height - 1) - border_size):
self.tiles[x][y] = Wall()
elif y < border_size + air_buffer:
self.tiles[x][y] = Air()
self.update()
def generate_land(self,hm):
print hm.w, hm.h
#self.noise = perlin_noise.PerlinNoiseGenerator()
#self.noise.generate_noise(self.w, self.h, 1, 16)
#print str(self.noise.noise[1][1])
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.5, 0.8)
print "scale", str(libtcod.heightmap_get_value(hm, 1, 1))
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.noise_set_type(self.noise, libtcod.NOISE_PERLIN)
libtcod.heightmap_scale_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.5, 0.8)
# self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
# libtcod.heightmap_add_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#
libtcod.heightmap_normalize(hm, 0, 255)
print "normalized", str(libtcod.heightmap_get_value(hm, 1, 1))
return hm
def make_house():
bsp_tree = tcod.bsp_new_with_size(0, 0, HOUSE_WIDTH - 1, HOUSE_HEIGHT - 1)
tcod.bsp_split_recursive(bsp_tree, 0, BSP_DEPTH, MIN_ROOM_WIDTH, MIN_ROOM_HEIGHT,
MAX_H_RATIO, MAX_V_RATIO)
tcod.bsp_traverse_inverted_level_order(bsp_tree, handle_node)
house_array[-1][-1] = Tile("wall", True, True)
noise = tcod.noise_new(2, HURST, LACNULARITY)
for x in xrange(HOUSE_WIDTH):
for y in xrange(HOUSE_HEIGHT):
if tcod.noise_get_turbulence(noise, [x, y], 32.0, tcod.NOISE_SIMPLEX) > THRESHOLD:
house_array[y][x] = Tile("floor", True, True)
def generate_land(self, hm):
print hm.w, hm.h
#self.noise = perlin_noise.PerlinNoiseGenerator()
#self.noise.generate_noise(self.w, self.h, 1, 16)
#print str(self.noise.noise[1][1])
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.5, 0.8)
print "scale", str(libtcod.heightmap_get_value(hm, 1, 1))
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.noise_set_type(self.noise, libtcod.NOISE_PERLIN)
libtcod.heightmap_scale_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.5, 0.8)
# self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
# libtcod.heightmap_add_fbm(hm, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#
libtcod.heightmap_normalize(hm, 0, 255)
print "normalized", str(libtcod.heightmap_get_value(hm, 1, 1))
return hm
def __init__(self, width, height):
self.size = width
self.width = width
self.height = height
self.units = []
self.selected_unit = None
self.world_img = libtcod.image_new(self.width, self.height)
self.ground_map = libtcod.map_new(width, height)
self.deepsea_map = libtcod.map_new(width, height)
self.noise_zoom = 5.0
self.noise_octaves = 8.0
self.center = [self.width/2, self.height/2]
self.map_list = [[Tile(True, libtcod.black) for y in range(height)] for x in range(width)]
self.world_noise = libtcod.noise_new(2)
self.ocean_noise = libtcod.noise_new(2)
libtcod.noise_set_type(self.world_noise, libtcod.NOISE_PERLIN)
self.generate_land()
def __init__(self, w, h):
global TROPICS_THRESHOLD, TEMPERATE_THRESHOLD, TAIGA_THRESHOLD
self.w = w
self.h = h
self.equator = h / 2
TROPICS_THRESHOLD = (self.equator / 2) / 3
TEMPERATE_THRESHOLD = self.equator / 2
TAIGA_THRESHOLD = self.equator - self.equator * 0.1
self.tiles = [[Tile(ix, iy, False, map_tile=True) for iy in range(h)]
for ix in range(w)]
x, y = 0, 0
self.traffic = [[0 for y in range(h)] for x in range(w)]
#this holds the *colour* value of the tiles temps.
self.temperature_map = [[0 for y in range(h)] for x in range(w)]
self.moisture_map = [[0 for y in range(h)] for x in range(w)]
self.hm = libtcod.heightmap_new(self.w, self.h)
self.hm2 = libtcod.heightmap_new(self.w, self.h)
self.hm3 = libtcod.heightmap_new(self.w, self.h)
self.generate_land(self.hm)
self.generate_land(self.hm2)
self.generate_land(self.hm3)
libtcod.noise_set_type(self.noise, libtcod.NOISE_SIMPLEX)
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
#self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
#libtcod.heightmap_add_fbm(self.hm3, self.noise, 1, 1, 0, 0, 8, 0.8, 0.5)
self.multiply_noise()
self.multiply_noise()
libtcod.heightmap_normalize(self.hm, 0, 255)
#libtcod.heightmap_normalize(self.hm2, 0, 255)
#libtcod.heightmap_normalize(self.hm3, 0, 255)
#libtcod.heightmap_rain_erosion(self.hm, (self.w + self.h)*4, 0.5, 0.1, None)
self.add_noise()
self.turn_to_tiles()
self.determine_temperatures()
self.normalise_temperatures()
self.wind_gen = Particle_Map(self, 1500)
self.generate_mini_map(10)
self.cities = []
self.dungeons = []
self.generate_city(libtcod.random_get_int(0, 4, 10))
self.generate_dungeons(10)
def render_all():
global fov_map, color_dark_wall, color_light_wall
global color_dark_ground, color_light_ground
global fov_recompute, FOV_TORCH, FOV_TORCHX, FOV_NOISE, noise
dx = 0.0
dy = 0.0
di = 0.0
if fov_recompute:
# recompute FOV if needed (the player moved or something)
fov_recompute = False
libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
if FOV_TORCH:
FOV_TORCHX += 0.2
tdx = [FOV_TORCHX + 20.0]
dx = libtcod.noise_simplex(noise, tdx) * 1.5
tdx[0] += 30.0
dy = libtcod.noise_simplex(noise, tdx) * 1.5
di = 0.2 * libtcod.noise_simplex(noise, [FOV_TORCHX])
FOV_NOISE = libtcod.noise_new(1, 1.0, 1.0)
# go through all tiles, and set their background color according to the FOV
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
visible = libtcod.map_is_in_fov(fov_map, x, y)
wall = map[x][y].block_sight
if not visible:
# if it's not visible right now, the player can only see it if it's explored
if map[x][y].explored:
if wall:
libtcod.console_set_back(con, x, y, color_dark_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_back(con, x, y, color_dark_ground, libtcod.BKGND_SET)
else:
# it's visible
if wall:
libtcod.console_set_back(con, x, y, color_light_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_back(con, x, y, color_light_ground, libtcod.BKGND_SET)
# since it's visible, explore it
map[x][y].explored = True
# draw all objects in the list
for object in objects:
object.draw()
# blit the contents of "con" to the root console
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
def initialize_fov():
global fov_recompute, fov_map, fov_noise
fov_recompute = True
libtcod.console_clear(con) # Unexplored areas start black (which
# is the default background color)
#create the FOV map, according to the generated map
fov_noise = libtcod.noise_new(1, 1.0, 1.0)
fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
libtcod.map_set_properties(fov_map, x, y,
not map[x, y].block_sight,
not map[x, y].blocked)
def initialze(scale=50, weather=False):
global noise_field, height_map
noise_field = libtcod.noise_new(2, 0.5, 2.0, rnd) # 0.5f and 2.0f
libtcod.noise_set_type(noise_field, libtcod.NOISE_SIMPLEX)
height_map = libtcod.heightmap_new(Constants.MAP_WIDTH, Constants.MAP_HEIGHT)
for y in range(Constants.MAP_HEIGHT):
for x in range(Constants.MAP_WIDTH):
libtcod.heightmap_set_value(height_map, x, y, get_noise_value(x, y, scale=scale))
libtcod.heightmap_normalize(height_map, 0.0, 1.0)
# libtcod.heightmap_add_hill(height_map, 40, 40, 6, 0.8)
if weather:
libtcod.heightmap_rain_erosion(height_map, 5000, 0.75, .75)
def initialize_fov():
global fov_recompute, fov_map, fov_noise
fov_recompute = True
libtcod.console_clear(con) # Unexplored areas start black (which
# is the default background color)
#create the FOV map, according to the generated map
fov_noise = libtcod.noise_new(1, 1.0, 1.0)
fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
libtcod.map_set_properties(fov_map, x, y,
not map[x, y].block_sight,
not map[x, y].blocked)
def _build_background(self):
"""
Make a background noise that will more or less look like
an old map.
"""
noise = tcod.noise_new(2)
tcod.noise_set_type(noise, tcod.NOISE_SIMPLEX)
background = []
for y in range(self.height):
background.append([])
for x in range(self.width):
background[y].append(
tcod.noise_get_turbulence(noise, [y / 100.0, x / 100.0],
32.0))
tcod.noise_delete(noise)
return background
def Percipitaion(preciphm, temphm):
libtcod.heightmap_add(preciphm, 2)
for x in xrange(WORLD_WIDTH):
for y in xrange(WORLD_HEIGHT):
temp = libtcod.heightmap_get_value(temphm, x, y)
precip = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(preciphm, precip, 2, 2, 0, 0, 32, 1, 1)
libtcod.heightmap_normalize(preciphm, 0.0, 1.0)
return
def _build_background(self):
"""
Make a background noise that will more or less look like
an old map.
"""
noise = tcod.noise_new(2)
tcod.noise_set_type(noise, tcod.NOISE_SIMPLEX)
background = []
for y in range(self.height):
background.append([])
for x in range(self.width):
background[y].append(
tcod.noise_get_turbulence(noise,
[y / 100.0, x / 100.0], 32.0))
tcod.noise_delete(noise)
return background
def initialze(scale=50, weather=False):
global noise_field, height_map
noise_field = libtcod.noise_new(2, 0.5, 2.0, rnd) # 0.5f and 2.0f
libtcod.noise_set_type(noise_field, libtcod.NOISE_SIMPLEX)
height_map = libtcod.heightmap_new(Constants.MAP_WIDTH,
Constants.MAP_HEIGHT)
for y in range(Constants.MAP_HEIGHT):
for x in range(Constants.MAP_WIDTH):
libtcod.heightmap_set_value(height_map, x, y,
get_noise_value(x, y, scale=scale))
libtcod.heightmap_normalize(height_map, 0.0, 1.0)
# libtcod.heightmap_add_hill(height_map, 40, 40, 6, 0.8)
if weather:
libtcod.heightmap_rain_erosion(height_map, 5000, 0.75, .75)
def generateDepth(self):
#noise_octaves = 4.0
noise_zoom = 2.0
noise_hurst = libtcod.NOISE_DEFAULT_HURST
noise_lacunarity = libtcod.NOISE_DEFAULT_LACUNARITY
mapped = self.mappedArea
water_color = libtcod.sky
if self.mapType == "desert":
water_level = 0.04
else:
water_level = 0.07
noise = libtcod.noise_new(2, noise_hurst, noise_lacunarity)
for y in range(self.height):
for x in range(self.width):
f = [noise_zoom * x / (self.width), noise_zoom * y / (self.height)]
noisefloat = abs(libtcod.noise_get(noise, f, libtcod.NOISE_PERLIN))
if noisefloat >= float(0) and noisefloat <= water_level:
tile = mapped[x][y]
tile.tileType = "water"
tile.blocked = False
tile.block_sight = False
tile.slows = True
#Depth = Color darkness
depth = int(10 - (noisefloat * 100))
tile.color = water_color - libtcod.Color(5 * depth, 5 * depth, 5 * depth)
tile.height = 0 - depth
else:
tile = mapped[x][y]
height = int(noisefloat / 0.03)
if height > 12:
height = 12
tile.height = height
#Block the edges of the map so player can't crash the game
for y in range(self.height):
#mapped[0][y].tileType = None
mapped[0][y].blocked = True
mapped[self.width-1][y].blocked = True
for x in range(self.width):
mapped[x][0].blocked = True
mapped[x][self.height-1].blocked = True
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 Percipitaion(preciphm):
libtcod.heightmap_add(preciphm, 2)
for x in xrange(WORLD_WIDTH):
for y in xrange(WORLD_HEIGHT):
if y > WORLD_HEIGHT/2 - WORLD_HEIGHT/10 and y < WORLD_HEIGHT/2 + WORLD_HEIGHT/10:
val = y
val = abs(y - WORLD_HEIGHT/2)
libtcod.heightmap_set_value(preciphm, x, y, val/4)
precip = libtcod.noise_new(2,libtcod.NOISE_DEFAULT_HURST, libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(preciphm,precip ,8, 8, 0, 0, 32, 1, 1)
libtcod.heightmap_normalize(preciphm, 0.0, 1.0)
return
def get_cylindrical_projection(stars, width=360, height=180):
"""
Return a tcod console instance of width and height that renders an equirectangular projection of the given list of stars.
"""
console = tcod.console_new(width, height)
for star in stars:
azimuthal = int((star.azimuthal * width) / (2 * math.pi))
polar = int((star.polar / math.pi) * height)
# Color Work
rgb = temperature_to_rgb(random.uniform(4000, 20000))
brightness = 1.0 - star.radial * 0.75
color = tcod.Color(rgb[0], rgb[1], rgb[2])
(h, s, v) = tcod.color_get_hsv(color)
tcod.color_set_hsv(color, h, s, brightness)
tcod.console_put_char_ex(console, azimuthal, polar, star.sprite, color,
tcod.black)
# Background Texture
noise3d = tcod.noise_new(3)
for map_x in range(width):
for map_y in range(height):
azimuthal = (map_x / (width * 1.0)) * 2.0 * math.pi
polar = (map_y / (height * 1.0)) * math.pi
x = math.sin(polar) * math.cos(azimuthal)
y = math.sin(polar) * math.sin(azimuthal)
z = math.cos(polar)
blue = int(
tcod.noise_get_turbulence(noise3d, [x, y, z], 32.0) * 16.0 +
16.0)
green = int(tcod.noise_get(noise3d, [x, y, z]) * 8.0 + 8.0)
red = int(tcod.noise_get_fbm(noise3d, [x, y, z], 32.0) * 4.0 + 4.0)
background = tcod.Color(red, green, blue)
if map_y == height / 2 or map_x == 0 or map_x == width / 2:
background = tcod.darkest_yellow
tcod.console_set_char_background(console, map_x, map_y, background)
tcod.noise_delete(noise3d)
return console
def generateWater(self):
#noise_octaves = 4.0
noise_zoom = 2.0
noise_hurst = libtcod.NOISE_DEFAULT_HURST
noise_lacunarity = libtcod.NOISE_DEFAULT_LACUNARITY
mapped = self.mappedArea
water_color = libtcod.sky
water_color1 = water_color - libtcod.Color(6, 6, 6)
water_color2 = water_color1 - libtcod.Color(6, 6, 6)
water_color3 = water_color2 - libtcod.Color(8, 8, 8)
noise = libtcod.noise_new(2, noise_hurst, noise_lacunarity)
for y in range(self.height):
for x in range(self.width):
f = [noise_zoom * x / (self.width), noise_zoom * y / (self.height)]
noisefloat = abs(libtcod.noise_get(noise, f, libtcod.NOISE_PERLIN))
if noisefloat >= float(0) and noisefloat <= 0.08:
tile = mapped[x][y]
tile.tileType = "water"
tile.blocked = False
tile.block_sight = False
tile.slows = True
#Depth = Color darkness
depth = 10 - (noisefloat * 100)
if depth <= 5:
tile.color = water_color
elif 5 < depth <= 7:
tile.color = water_color1
elif 7 < depth < 9:
tile.color = water_color2
else:
tile.color = water_color3
#Block the edges of the map so player can't crash the game
for y in range(self.height):
#mapped[0][y].tileType = None
mapped[0][y].blocked = True
mapped[self.width-1][y].blocked = True
for x in range(self.width):
mapped[x][0].blocked = True
mapped[x][self.height-1].blocked = True
def map_init_noise(width, height):
map_gen = []
noise = libtcodpy.noise_new(2)
libtcodpy.noise_set_type(noise, libtcodpy.NOISE_SIMPLEX)
for x in range(0, width):
aux = []
for y in range(0, height):
if libtcodpy.noise_get(noise, [(x + 1) / 3, y / 3]) > 0.6:
aux.append(
Tile(False, True, False, 0,
GAME.tiles.image_at((0, 0, 32, 32)),
GAME.tiles.image_at((0, 32, 32, 32)))) # WALL
else:
aux.append(
Tile(True, False, True, 0,
GAME.tiles.image_at((32, 0, 32, 32)),
GAME.tiles.image_at((32, 32, 32, 32)))) #F LOOR
map_gen.append(aux)
map_gen = map_set_borders(map_gen, width - 1, height - 1) # BORDERS
return map_gen
def test_heightmap():
hmap = libtcodpy.heightmap_new(16, 16)
repr(hmap)
noise = libtcodpy.noise_new(2)
# basic operations
libtcodpy.heightmap_set_value(hmap, 0, 0, 1)
libtcodpy.heightmap_add(hmap, 1)
libtcodpy.heightmap_scale(hmap, 1)
libtcodpy.heightmap_clear(hmap)
libtcodpy.heightmap_clamp(hmap, 0, 0)
libtcodpy.heightmap_copy(hmap, hmap)
libtcodpy.heightmap_normalize(hmap)
libtcodpy.heightmap_lerp_hm(hmap, hmap, hmap, 0)
libtcodpy.heightmap_add_hm(hmap, hmap, hmap)
libtcodpy.heightmap_multiply_hm(hmap, hmap, hmap)
# modifying the heightmap
libtcodpy.heightmap_add_hill(hmap, 0, 0, 4, 1)
libtcodpy.heightmap_dig_hill(hmap, 0, 0, 4, 1)
libtcodpy.heightmap_rain_erosion(hmap, 1, 1, 1)
libtcodpy.heightmap_kernel_transform(hmap, 3, [-1, 1, 0], [0, 0, 0],
[.33, .33, .33], 0, 1)
libtcodpy.heightmap_add_voronoi(hmap, 10, 3, [1, 3, 5])
libtcodpy.heightmap_add_fbm(hmap, noise, 1, 1, 1, 1, 4, 1, 1)
libtcodpy.heightmap_scale_fbm(hmap, noise, 1, 1, 1, 1, 4, 1, 1)
libtcodpy.heightmap_dig_bezier(hmap, [0, 16, 16, 0], [0, 0, 16, 16], 1, 1,
1, 1)
# read data
libtcodpy.heightmap_get_value(hmap, 0, 0)
libtcodpy.heightmap_get_interpolated_value(hmap, 0, 0)
libtcodpy.heightmap_get_slope(hmap, 0, 0)
libtcodpy.heightmap_get_normal(hmap, 0, 0, 0)
libtcodpy.heightmap_count_cells(hmap, 0, 0)
libtcodpy.heightmap_has_land_on_border(hmap, 0)
libtcodpy.heightmap_get_minmax(hmap)
libtcodpy.noise_delete(noise)
libtcodpy.heightmap_delete(hmap)
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 generate(width, height):
_weight_map, _tile_map, _solids, _node_grid = mapgen.create_map(width, height)
_c_x, _c_y = width/2, height/2
_zoom = 1.2
_noise = tcod.noise_new(3)
_possible_trees = set()
for y in range(height):
for x in range(width):
_c_dist = numbers.float_distance((x, y), (_c_x, _c_y)) / float(max([width, height]))
_noise_values = [(_zoom * x / (constants.MAP_VIEW_WIDTH)),
(_zoom * y / (constants.MAP_VIEW_HEIGHT))]
_noise_value = numbers.clip(tcod.noise_get_turbulence(_noise, _noise_values, tcod.NOISE_SIMPLEX) - .7, .5-_c_dist, 1)
if _noise_value > .3:
_tile = tiles.grass(x, y)
_possible_trees.add((x, y))
elif _noise_value > .2:
if random.uniform(.2, .3) + (_noise_value-.2) > .3:
if _c_dist < .35:
_tile = tiles.grass(x, y)
_possible_trees.add((x, y))
else:
_tile = tiles.grass(x, y)
_possible_trees.add((x, y))
else:
#TODO: Slowly dither in swamp water
if _c_dist < .35:
_tile = tiles.swamp_water(x, y)
else:
_tile = tiles.swamp_water(x, y)
elif _noise_value >= 0:
_r_val = random.uniform(0, .2) + (_noise_value)
if _r_val > .2:
_tile = tiles.swamp_water(x, y)
else:
if random.uniform(0, .2) + (_noise_value) > .2:
_tile = tiles.swamp_water(x, y)
else:
_tile = tiles.tall_grass(x, y)
elif _noise_value < 0:
_tile = tiles.tall_grass(x, y)
_possible_trees.add((x, y))
else:
_tile = tiles.swamp(x, y)
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
#############
#Trader camp#
#############
_s_x, _s_y = ((width/2)-20, (height/2)-20)
_building_space = set()
_walls = set()
#Building
_width, _height = random.choice([(20, 20), (12, 20), (20, 12)])
_random_dir = random.randint(0, 3)
if _random_dir == 1:
_door_x = _width / 2
_door_y = 0
elif _random_dir == 2:
_door_x = _width / 2
_door_y = _height
elif _random_dir == 3:
_door_x = 0
_door_y = _height / 2
else:
_door_x = _width
_door_y = _height / 2
if _width > _height:
if _random_dir in [1, 3]:
_mod = .75
else:
_mod = .25
_trade_room_x = int(round(_width * _mod))
_trade_room_y = -1
_trade_window_x = _trade_room_x
_trade_window_y = _height / 2
else:
if _random_dir == 1:
_mod = .75
else:
_mod = .25
_trade_room_x = -1
_trade_room_y = int(round(_height * _mod))
_trade_window_x = _width / 2
_trade_window_y = _trade_room_y
for y in range(_height+1):
_y = _s_y+y
for x in range(_width+1):
_x = _s_x+x
if (x, y) == (_door_x, _door_y):
_tile = tiles.concrete(_x, _y)
elif x == 0 or y == 0 or x == _width or y == _height:
_tile = tiles.wooden_fence(_x, _y)
_solids.add((_x, _y))
_walls.add((_x, _y))
else:
if x == _trade_window_x and y == _trade_window_y:
_tile = tiles.trade_window(_x, _y)
elif x == _trade_room_x or y == _trade_room_y:
_tile = tiles.wooden_fence(_x, _y)
_solids.add((_x, _y))
_walls.add((_x, _y))
else:
_tile = tiles.wood_floor(_x, _y)
_weight_map[_y][_x] = _tile['w']
_tile_map[_y][_x] = _tile
_building_space.add((_x, _y))
#Wall
_width, _height = _width * 4, _height * 4
_ground_space = set()
for y in range(_height + 1):
_y = _s_y + y
_yy = _y - int(round(_height * .4))
for x in range(_width + 1):
_x = _s_x + x
_xx = _x - int(round(_width * .4))
if random.uniform(0, 1) >= .75:
continue
if x == 0 or y == 0 or x == _width or y == _height:
_tile = tiles.wooden_fence(_xx, _yy)
else:
if (_xx, _yy) in _building_space:
continue
_ground_space.add((_xx, _yy))
continue
_weight_map[_yy][_xx] = _tile['w']
_tile_map[_yy][_xx] = _tile
_solids.add((_xx, _yy))
#Ground: Inside wall - outside building
_ground_seeds = random.sample(list(_ground_space - _building_space), 50)
for x, y in _ground_seeds:
_walker_x = x
_walker_y = y
_last_dir = -2, -2
for i in range(random.randint(80, 90)):
_tile = tiles.concrete_striped(_walker_x, _walker_y)
_weight_map[_walker_y][_walker_x] = _tile['w']
_tile_map[_walker_y][_walker_x] =_tile
_dir = random.randint(-1, 1), random.randint(-1, 1)
_n_x = _walker_x + _dir[0]
_n_y = _walker_y + _dir[1]
while (_n_x, _n_y) in _building_space or (_n_x, _n_y) in _solids or _last_dir == _dir:
_dir = random.randint(-1, 1), random.randint(-1, 1)
_n_x = _walker_x + _dir[0]
_n_y = _walker_y + _dir[1]
_last_dir = _dir[0] * -1, _dir[0] * -1
_walker_x = _n_x
_walker_y = _n_y
#Bushes around outside wall
#Campfires
"""for room in _rooms:
_build_doors = []
for plot_x, plot_y in room['plots']:
_room = _building[(plot_x, plot_y)]
_build_walls = ['north', 'south', 'east', 'west']
for n_plot_x, n_plot_y in [(plot_x-1, plot_y), (plot_x+1, plot_y), (plot_x, plot_y-1), (plot_x, plot_y+1)]:
if ((n_plot_x, n_plot_y) == _room['door_plot']) or (not _build_doors and not (n_plot_x, n_plot_y) in room['plots'] and (n_plot_x, n_plot_y) in _building):
if n_plot_x - plot_x == -1:
_build_doors.append('west')
if 'west' in _build_walls:
_build_walls.remove('west')
elif n_plot_x - plot_x == 1:
_build_doors.append('east')
if 'east' in _build_walls:
_build_walls.remove('east')
if n_plot_y - plot_y == -1:
_build_doors.append('north')
if 'north' in _build_walls:
_build_walls.remove('north')
elif n_plot_y - plot_y == 1:
_build_doors.append('south')
if 'south' in _build_walls:
_build_walls.remove('south')
if (n_plot_x, n_plot_y) in _building:
if n_plot_x - plot_x == -1 and not _building[(n_plot_x, n_plot_y)]['type'] in buildinggen.ROOM_TYPES[room['type']]['avoid_rooms']:
if 'west' in _build_walls:
_build_walls.remove('west')
elif n_plot_x - plot_x == 1 and not _building[(n_plot_x, n_plot_y)]['type'] in buildinggen.ROOM_TYPES[room['type']]['avoid_rooms']:
if 'east' in _build_walls:
_build_walls.remove('east')
if n_plot_y - plot_y == -1 and not _building[(n_plot_x, n_plot_y)]['type'] in buildinggen.ROOM_TYPES[room['type']]['avoid_rooms']:
if 'north' in _build_walls:
_build_walls.remove('north')
elif n_plot_y - plot_y == 1 and not _building[(n_plot_x, n_plot_y)]['type'] in buildinggen.ROOM_TYPES[room['type']]['avoid_rooms']:
if 'south' in _build_walls:
_build_walls.remove('south')
_x, _y = (_s_x + (plot_x*_room_size)), (_s_y + (plot_y*_room_size))
for y in range(_y, _y+_room_size):
for x in range(_x, _x+_room_size):
if ((x-_x == 0 and 'west' in _build_walls) or (y-_y == 0 and 'north' in _build_walls) or (x-_x == _room_size-1 and 'east' in _build_walls) or (y-_y == _room_size-1 and 'south' in _build_walls)):
_weight_map[y][x] = _tile['w']
_tile_map[y][x] = tiles.wooden_fence(x, y)
_solids.add((x, y))
else:
_tile_map[y][x] = buildinggen.ROOM_TYPES[room['type']]['tiles'](x, y)
_building_space.add((x, y))
for y in range(_y, _y+_room_size):
for x in range(_x-1, _x+_room_size+1):
if (x-_x in [-1, 0] and 'west' in _build_doors and (y-_y<=2 or y-_y>=_room_size-3)) or (x-_x in [_room_size, _room_size+1] and 'east' in _build_doors and (y-_y<=2 or y-_y>=_room_size-3)):
_weight_map[y][x] = _tile['w']
_tile_map[y][x] = tiles.wooden_fence(x, y)
_solids.add((x, y))
for y in range(_y-1, _y+_room_size+1):
for x in range(_x, _x+_room_size):
if (y-_y in [-1, 0] and 'north' in _build_doors and (x-_x<=2 or x-_x>=_room_size-3)) or (y-_y in [_room_size, _room_size+1] and 'south' in _build_doors and (x-_x<=2 or x-_x>=_room_size-3)):
_weight_map[y][x] = _tile['w']
_tile_map[y][x] = tiles.wooden_fence(x, y)
_solids.add((x, y))
_last_plot_x, _last_plot_y = plot_x, plot_y
#TODO: Make this into a function?
_min_x, _max_x = (width, 0)
_min_y, _max_y = (height, 0)
for x, y in _building:
_x, _y = (_s_x + (x*_room_size)), (_s_y + (y*_room_size))
if _x > _max_x:
_max_x = _x
if _x < _min_x:
_min_x = _x
if _y > _max_y:
_max_y = _y
if _y < _min_y:
_min_y = _y"""
_plot_pole_x, _plot_pole_y = _s_x, _s_y
_tree_plots = _possible_trees - _solids
_tree_plots = list(_tree_plots - _building_space)
_trees = {}
_used_trees = random.sample(_tree_plots, numbers.clip(int(round((width * height) * .001)), 0, len(_tree_plots)))
_bush_plots = set(_tree_plots) - set(_used_trees)
_used_bush = random.sample(_bush_plots, numbers.clip(int(round((width * height) * .003)), 0, len(_bush_plots)))
_swamp_plots = set(_tree_plots) - set(_used_bush)
_used_swamp = random.sample(_swamp_plots, numbers.clip(int(round((width * height) * .003)), 0, len(_swamp_plots)))
for x, y in _used_trees:
_size = random.randint(7, 12)
_trees[x, y] = _size
for w in range(random.randint(1, 2)):
_walker_x = x
_walker_y = y
_walker_direction = random.randint(0, 359)
for i in range(random.randint(_size/4, _size/2)):
_actual_x, _actual_y = int(round(_walker_x)), int(round(_walker_y))
if _actual_x < 0 or _actual_y < 0 or _actual_x >= width or _actual_y >= height or (_actual_x, _actual_y) in _solids:
break
_center_mod = numbers.float_distance((_actual_x, _actual_y), (x, y)) / float(_size)
_tile = tiles.tree(_actual_x, _actual_y)
_weight_map[_actual_y][_actual_x] = _tile['w']
_tile_map[_actual_y][_actual_x] = _tile
if random.randint(0, 3):
_trees[_actual_x, _actual_y] = random.randint(1, _size)
_solids.add((_actual_x, _actual_y))
_walker_direction += random.randint(-45, 45)
_n_x, _n_y = numbers.velocity(_walker_direction, 1)
_walker_x += _n_x
_walker_y += _n_y
for x, y in _used_bush:
_center_mod = numbers.float_distance((x, y), (_plot_pole_x, _plot_pole_y)) / 60.0
_walker_x = x
_walker_y = y
for i in range(int(round(random.randint(44, 55) * _center_mod))):
_tile = tiles.swamp_water(_walker_x, _walker_y)
_weight_map[_walker_y][_walker_x] = _tile['w']
_tile_map[_walker_y][_walker_x] =_tile
_walker_x += random.randint(-1, 1)
_walker_y += random.randint(-1, 1)
if _walker_x < 0 or _walker_y < 0 or _walker_x >= width or _walker_y >= height or (_walker_x, _walker_y) in _solids:
break
for x, y in _used_swamp:
_center_mod = numbers.float_distance((x, y), (_plot_pole_x, _plot_pole_y)) / 120.0
_walker_x = x
_walker_y = y
for i in range(int(round(random.randint(44, 55) * (1-_center_mod)))):
_tile = tiles.swamp(_walker_x, _walker_y)
_weight_map[_walker_y][_walker_x] = _tile['w']
_tile_map[_walker_y][_walker_x] =_tile
_walker_x += random.randint(-1, 1)
_walker_y += random.randint(-1, 1)
if _walker_x < 0 or _walker_y < 0 or _walker_x >= width or _walker_y >= height or (_walker_x, _walker_y) in _solids:
break
mapgen.build_node_grid(_node_grid, _solids)
mapgen.add_plot_pole(_plot_pole_x, _plot_pole_y, 40, _solids)
_fsl = {'Terrorists': {'bases': 1, 'squads': 0, 'trader': True, 'type': life.human_runner},
'Militia': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.human_bandit}}
#'Wild Dogs': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.wild_dog}}
return width, height, _node_grid, mapgen.NODE_SETS.copy(), _weight_map, _tile_map, _solids, _fsl, _trees, _building_space - _walls
def create(self):
w = self.width = cfg.OW_WIDTH
h = self.height = cfg.OW_HEIGHT
th = cfg.OW_TREE_THRES
self.level = [[OverworldTile(j, i) for i in xrange(h)]
for j in xrange(w)]
self.console = libtcod.console_new(w, h)
backColor = libtcod.Color(0, 0, 0)
noise2d = libtcod.noise_new(2)
for x in xrange(w):
for y in xrange(h):
zoom = 0.09
f = [zoom * x, zoom * y]
val = libtcod.noise_get(noise2d, f)
c1 = int((((val * -1) + 1) / 2) * 30)
c2 = 10 + int(((val + 1) / 2) * 20)
if val > th:
self.level[x][y].setChar(23)
self.level[x][y].setColors(libtcod.Color(0, 200, 0),
libtcod.Color(0, 0, 0))
self.level[x][y].setBlocked(True)
else:
self.level[x][y].setChar(176)
self.level[x][y].setColors(libtcod.Color(0, c1, 0),
libtcod.Color(0, c2, 0))
while len(self.pathable) < 400:
self.findPathable()
self.clearUnpathableAreas()
#self.findPathable() # Now a final scan for the full area
# Place town
town_pos = random.choice(self.pathable)
town = OverworldTileEntity(town_pos[0], town_pos[1])
town.setColors(libtcod.Color(0, 100, 150), libtcod.Color(40, 40, 0))
self.tile_entity.append(town)
self.town = town
# Place dungeons
for i in xrange(cfg.DUNGEONS):
validLocation = False
pos = None
while not validLocation:
validLocation = True
pos = random.choice(self.pathable)
for entity in self.tile_entity:
if entity.position() == pos:
validLocation = False
dungeon = OverworldTileEntity(pos[0], pos[1])
dungeon.setColors(libtcod.Color(200, 0, 0),
libtcod.Color(40, 0, 0))
self.tile_entity.append(dungeon)
self.buildBlockedMap()
def generate(width, height):
_weight_map, _tile_map, _solids, _node_grid = mapgen.create_map(width, height)
_zoom = .95
_noise = tcod.noise_new(3)
_low_grass = 25
_fsl = {}
_building_space = set()
_walls = set()
_possible_trees = set()
_river_start_x = random.randint(int(round(width * .35)), int(round(width * .65)))
_river_start_y = 0#random.randint(int(round(height * .15)), int(round(height * .85)))
_x = _river_start_x
_y = _river_start_y
_px, _py = _river_start_x, _river_start_y
_river_direction = 270
_turn_rate = random.randint(-1, 1)
_river_tiles = set()
_river_size = random.randint(7, 10)
_ground_tiles = set()
_possible_camps = set()
while 1:
for i in range(4, 10):
for __x, __y in shapes.circle(_x, _y, _river_size):
if __x < 0 or __y < 0 or __x >= width or __y >= height or (__x, __y) in _solids:
continue
_river_tiles.add((__x, __y))
_tile = tiles.swamp_water(__x, __y)
_tile_map[__y][__x] = _tile
_weight_map[__y][__x] = _tile['w']
_river_direction += _turn_rate
_xv, _yv = numbers.velocity(_river_direction, 1)
_px += _xv
_py += _yv
_x = int(round(_px))
_y = int(round(_py))
if _x < 0 or _y < 0 or _x >= width or _y >= height or (_x, _y) in _solids:
break
if _x < 0 or _y < 0 or _x >= width or _y >= height:
break
_turn_rate = random.uniform(-2.5, 2.5)
_river_size = numbers.clip(_river_size + random.randint(-1, 1), 7, 10)
for y in range(height):
for x in range(width):
if (x, y) in _river_tiles:
continue
_tile = tiles.grass(x, y)
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
_ground_tiles.add((x, y))
tcod.noise_set_type(_noise, tcod.NOISE_WAVELET)
for y in range(height):
for x in range(width):
if (x, y) in _river_tiles:
continue
_noise_values = [(_zoom * x / (constants.MAP_VIEW_WIDTH)),
(_zoom * y / (constants.MAP_VIEW_HEIGHT))]
_noise_value = 100 * tcod.noise_get_turbulence(_noise, _noise_values, tcod.NOISE_WAVELET)
if _low_grass <= _noise_value <= 100:
_tile = tiles.tall_grass(x, y)
if _noise_value >= 40:
if not x < width * .15 and not x > width * .85 and not y < height * .15 and not y > height * .85:
_possible_camps.add((x, y))
if random.uniform(0, 1) > .5:
_possible_trees.add((x, y))
elif _noise_value >= _low_grass - 10 and 10 * random.uniform(0, 1) > _low_grass-_noise_value:
_tile = tiles.grass(x, y)
else:
_tile = tiles.rock(x, y)
_solids.add((x, y))
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
_trees = {}
_tree_plots = _possible_trees - _solids - _river_tiles
_used_trees = random.sample(_tree_plots, numbers.clip(int(round((width * height) * .002)), 0, len(_tree_plots)))
for x, y in _used_trees:
_size = random.randint(1, 3)
for _x, _y in shapes.circle(x, y, _size):
if _x < 0 or _y < 0 or _x >= width or _y >= height or (_x, _y) in _solids:
break
_tile = tiles.tree(_x, _y)
_weight_map[_y][_x] = _tile['w']
_tile_map[_y][_x] = _tile
_trees[_x, _y] = random.uniform(2, 3.5) * _size
_solids.add((_x, _y))
_ground_tiles = _ground_tiles - _solids
_plot_pole_x, _plot_pole_y = width/2, height/2
_bushes = random.sample(_ground_tiles, numbers.clip(int(round((width * height) * .0003)), 0, len(_ground_tiles)))
_camps = set()
while len(_possible_camps):
_camp_1 = random.choice(list(_possible_camps))
_possible_camps.remove(_camp_1)
_camps.add(_camp_1)
for camp_2 in _possible_camps.copy():
_dist = numbers.distance(_camp_1, camp_2)
if _dist <= 250:
_possible_camps.remove(camp_2)
for x, y in _bushes:
_walker_x = x
_walker_y = y
_last_dir = -2, -2
for i in range(random.randint(10, 15)):
_tile = tiles.tree(_walker_x, _walker_y)
_weight_map[_walker_y][_walker_x] = _tile['w']
_tile_map[_walker_y][_walker_x] =_tile
_dir = random.randint(-1, 1), random.randint(-1, 1)
_n_x = _walker_x + _dir[0]
_n_y = _walker_y + _dir[1]
if _n_x < 0 or _n_y < 0 or _n_x >= width or _n_y >= height or (_n_x, _n_y) in _solids:
break
_last_dir = _dir[0] * -1, _dir[0] * -1
_walker_x = _n_x
_walker_y = _n_y
_camp_info = {}
for c_x, c_y in _camps:
_building_walls = random.sample(['north', 'south', 'east', 'west'], random.randint(2, 3))
_broken_walls = random.sample(_building_walls, numbers.clip(random.randint(0, 3), 0, len(_building_walls)))
_camp = {'center': (c_x, c_y)}
_camp_ground = []
for y in range(-10, 10+1):
for x in range(-10, 10+1):
_x = x + c_x
_y = y + c_y
if (_x, _y) in _solids or (_x, _y) in _river_tiles:
continue
if (x == -10 and 'west' in _building_walls) or (y == -10 and 'north' in _building_walls) or (x == 10 and 'east' in _building_walls) or (y == 10 and 'south' in _building_walls):
if x == -10 and 'west' in _building_walls and 'west' in _broken_walls and random.uniform(0, 1) > .75:
continue
if x == 10 and 'east' in _building_walls and 'east' in _broken_walls and random.uniform(0, 1) > .75:
continue
if y == -10 and 'north' in _building_walls and 'north' in _broken_walls and random.uniform(0, 1) > .75:
continue
if y == 10 and 'south' in _building_walls and 'south' in _broken_walls and random.uniform(0, 1) > .75:
continue
_tile = tiles.wooden_fence(_x, _y)
_weight_map[_y][_x] = _tile['w']
_tile_map[_y][_x] = _tile
_solids.add((_x, _y))
elif (x > -10 and x <= 10) and (y > -10 and y <= 10):
_camp_ground.append((_x, _y))
_camp['ground'] = _camp_ground[:]
_camp_info[c_x, c_y] = _camp
mapgen.build_node_grid(_node_grid, _solids)
for c_x, c_y in _camps:
mapgen.add_plot_pole(c_x, c_y, 40, _solids)
_fsl = {'Terrorists': {'bases': 1, 'squads': 0, 'trader': False, 'type': life.human_runner}}
# #'Militia': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.human_bandit},
# 'Wild Dogs': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.wild_dog}}
return width, height, _node_grid, mapgen.NODE_SETS.copy(), _weight_map, _tile_map, _solids, _fsl, _trees, _building_space - _walls
def area_cell_create(width, height, p_blocked, p_unblocked, nudge, steps, border=True, exits=0, connect=True, seed=lt.random_get_instance()):
"""
:param width:
:param height:
:param p_blocked: - At least what percent of a valid area must be unblocked spaces.
:param p_unblocked: - At least what percent of a valid area must be blocked spaces.
:param nudge: - Higher number means more blocked space.
:param steps: - How many steps to run the automata.
:param border: - Requires a solid border?
:param exits: - If there's a solid border, how many exits should there be?
:return:
"""
print "---"
area = [[True for row in xrange(width)] for col in xrange(height)]
# Create noise
print "Generating noise..."
area_noise = lt.noise_new(2, random=seed)
for col in xrange(height):
for row in xrange(width):
if border:
if row < 3 or row > width - 3:
area[col][row] = 1
elif col < 3 or col > height - 3:
area[col][row] = 1
else:
coords = (col, row)
n = lt.noise_get(area_noise, coords)
area[col][row] = int(round(abs(n) + nudge, 0))
else:
coords = (col, row)
n = lt.noise_get(area_noise, coords)
area[col][row] = int(round(abs(n) + nudge, 0))
visualize(area)
# Add in exits.
print "Adding exits..."
if exits > 0:
exitcoords = []
for direction in xrange(exits):
row_size = random.randint(4, 10)
col_size = random.randint(4, 10)
if direction == 0:
row_loc = random.randint(width/2 - width/4, width/2 + width/4)
col_loc = height - col_size
for col in xrange(col_size):
for row in xrange(row_size):
area[col_loc+col][row_loc+row] = 0
for row in xrange(row_size):
coords = (height - 2, row_loc + row)
area[coords[0] + 1][coords[1]] = -1
exitcoords.append(coords)
visualize(area)
# Begin cellular automata
print "Running automata..."
for i in xrange(steps):
next_step = area
for col in xrange(height):
for row in xrange(width):
neighbors = count_neighbors(col, row, area)
# Check births and survivals.
# Current rules are: B5678 / S45678. May want to add the ability to affect that too.
if area[col][row] == 1 and neighbors < 4:
next_step[col][row] = 0
elif area[col][row] == 0 and neighbors > 4:
next_step[col][row] = 1
area = next_step
visualize(area)
# Mark as ground only those ground tiles which can be reached from an arbitrary point near the center OR an exit.
print "Counting reach..."
while True:
if exits == 0:
row = random.randint(width/2 - 10, width/2 + 10)
col = random.randint(height/2 - 10, height/2 + 10)
elif exits > 0:
col, row = exitcoords.pop()
if area[col][row] == 0:
reachable(col, row, area, 1)
break
# Replace 0's (unreachable sections) with 1 (blocked). and 2's (reachable sections)
# with 0 (unblocked), while counting how many there are.
unblocked_n = 0.
blocked_n = 0.
for col in xrange(height):
for row in xrange(width):
if area[col][row] == 1 or (area[col][row] == 0 and connect):
area[col][row] = 1
blocked_n += 1
elif area[col][row] > 1 or (area[col][row] == 0 and not connect):
if col == 0 or col == height - 1 or row == 0 or row == width - 1:
area[col][row] = -1
unblocked_n += 1
# Ensure the map fits our parameters.
print "Testing parameters..."
visualize(area)
if unblocked_n <= width * height * p_unblocked:
print "Not enough unblocked: ", unblocked_n, "<", width * height * p_unblocked
if blocked_n <= width * height * p_blocked:
print "Not enough blocked.", blocked_n, "<", width * height * p_blocked
return False
print "Area generated."
return area
def multiply_noise(self):
self.noise = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.noise_set_type(self.noise, libtcod.NOISE_PERLIN)
libtcod.heightmap_scale_fbm(self.hm, self.noise, 1, 1, 1, 1, 16, 0.5,
0.5)
def generate(width, height):
_weight_map, _tile_map, _solids, _node_grid = mapgen.create_map(
width, height)
_zoom = .95
_noise = tcod.noise_new(3)
_low_grass = 25
_fsl = {}
_building_space = set()
_walls = set()
_possible_trees = set()
_river_direction = 270
_turn_rate = random.randint(-1, 1)
_river_tiles = set()
_river_size = random.randint(7, 10)
_ground_tiles = set()
_possible_camps = set()
_trees = {}
_blueprint = sculpted.create_blueprint(sculpted.ROOMS)
_room_size = 17
_door_width = 1
_place_x, _place_y = 5, 10
_floor = set()
_lights = []
_spawns = {'defending': set(), 'attacking': set()}
#_room_bitmask_maps = {}
_min_door_pos = (_room_size / 2) - _door_width
_max_door_pos = (_room_size / 2) + _door_width
for y in range(_blueprint['height']):
for x in range(_blueprint['width']):
_o_bitmask = _blueprint['bitmask_map'][y, x]
_bitmask = _blueprint['bitmask_map'][y, x]
_door_bitmask = _blueprint['bitmask_door_map'][y, x]
if not _bitmask:
continue
if _bitmask < 100:
_bitmask += 100
else:
_room_name = _blueprint['room_lookup'][_blueprint['room_map'][
y, x]]
_wall_offset = 0 #Don't even think about touching this...
_wall_padding = range(
_blueprint['rooms'][_room_name]['wall_padding'] + 1)
_wall_padding_actual = range(
_wall_offset,
_blueprint['rooms'][_room_name]['wall_padding'] + 1)
_wall_padding_2_actual = [(_room_size - 1) - i for i in range(
_wall_offset,
_blueprint['rooms'][_room_name]['wall_padding'] + 1)]
_wall_padding_2 = [(_room_size - 1) - i for i in range(
_blueprint['rooms'][_room_name]['wall_padding'] + 1)]
_wall_padding_3 = range(
_blueprint['rooms'][_room_name]['doorway_padding'] + 1)
_wall_padding_3_actual = range(
_wall_offset,
_blueprint['rooms'][_room_name]['doorway_padding'] + 1)
_wall_padding_4 = [(_room_size - 1) - i for i in range(
_blueprint['rooms'][_room_name]['doorway_padding'] + 1)]
_wall_padding_4_actual = [(_room_size - 1) - i for i in range(
_wall_offset,
_blueprint['rooms'][_room_name]['doorway_padding'] + 1)]
_wall_bitmask = 0
logging.debug('Building: %s' % _room_name)
if _o_bitmask > 100 and _o_bitmask < 200:
_wall_bitmask = _o_bitmask
for y1 in range(_room_size):
for x1 in range(_room_size):
_placed = False
_p_x, _p_y = (x * _room_size) + x1, (y * _room_size) + y1
if _o_bitmask > 100 and _o_bitmask < 200:
if y1 in _wall_padding and not _bitmask in [
101, 103, 105, 107, 109, 111, 113, 115
]:
if y1 in _wall_padding_actual:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
elif y1 in _wall_padding_2 and not _bitmask in [
104, 105, 106, 107, 112, 113, 114, 115
]:
if y1 in _wall_padding_2_actual:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
if x1 in _wall_padding_2 and not _bitmask in [
102, 103, 106, 107, 110, 111, 114, 115
]:
if x1 in _wall_padding_2_actual:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
elif x1 in _wall_padding and not _bitmask in [
108, 109, 110, 111, 112, 113, 114, 115
]:
if x1 in _wall_padding_actual:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
else:
if y1 == 0 and _bitmask in [
101, 103, 105, 107, 109, 111, 113, 115
]:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
elif y1 == _room_size - 1 and _bitmask in [
104, 105, 106, 107, 112, 113, 114, 115
]:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
if x1 == _room_size - 1 and _bitmask in [
102, 103, 106, 107, 110, 111, 114, 115
]:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
elif x1 == 0 and _bitmask in [
108, 109, 110, 111, 112, 113, 114, 115
]:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_placed = True
if not _placed and _o_bitmask > 100 and not _door_bitmask:
_floor.add(
(_place_x + _p_x, _place_y + _p_y, _room_name))
elif _door_bitmask:
_doorway_placed = False
if y1 in _wall_padding_3 and _door_bitmask in [
101, 103, 105, 107, 109, 111, 113, 115
]:
if x1 < _min_door_pos or x1 > _max_door_pos:
#if x1 in _wall_padding_3_actual:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_doorway_placed = True
elif (_place_x + _p_x, _place_y + _p_y) in _solids:
_solids.remove(
(_place_x + _p_x, _place_y + _p_y))
elif y1 in _wall_padding_4 and _door_bitmask in [
104, 105, 106, 107, 112, 113, 114, 115
]:
if x1 < _min_door_pos or x1 > _max_door_pos:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_doorway_placed = True
elif (_place_x + _p_x, _place_y + _p_y) in _solids:
_solids.remove(
(_place_x + _p_x, _place_y + _p_y))
if x1 in _wall_padding_4 and _door_bitmask in [
102, 103, 106, 107, 110, 111, 114, 115
]:
if y1 < _min_door_pos or y1 > _max_door_pos:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_doorway_placed = True
elif (_place_x + _p_x, _place_y + _p_y) in _solids:
_solids.remove(
(_place_x + _p_x, _place_y + _p_y))
elif x1 in _wall_padding_3 and _door_bitmask in [
108, 109, 110, 111, 112, 113, 114, 115
]:
if y1 < _min_door_pos or y1 > _max_door_pos:
_solids.add((_place_x + _p_x, _place_y + _p_y))
_doorway_placed = True
elif (_place_x + _p_x, _place_y + _p_y) in _solids:
_solids.remove(
(_place_x + _p_x, _place_y + _p_y))
if not _doorway_placed and not _placed:
_floor.add(
(_place_x + _p_x, _place_y + _p_y, _room_name))
_lookup = {(0, -1): 1, (1, 0): 2, (0, 1): 4, (-1, 0): 8}
_new_floors, _new_solids, _windows, _new_lights, _new_spawns = roomgen.spawn_items(
_blueprint['rooms'], _blueprint['bitmask_map'],
_blueprint['bitmask_door_map'], _floor, _solids, _room_size,
_room_size, (_place_x, _place_y), _tile_map, _weight_map)
_floor_new = set()
for x, y, room_name in _floor.copy():
_floor_new.add((x, y))
_spawns['defending'].update(_new_spawns)
_spawns['attacking'].add((70, 5))
_floor = _floor_new
_floor.update(_new_floors)
_solids.update(_new_solids)
_remove_solids = set()
_solids = _solids - _windows
_lights.extend(_new_lights)
for x, y in _solids:
#_count = 0
_delete = True
for x1, y1 in [(0, -1), (1, 0), (0, 1), (-1, 0), (-1, -1), (1, -1),
(-1, 1), (1, 1)]:
_x = x + x1
_y = y + y1
if (_x, _y) in _floor:
_delete = False
#_count += 1
if _delete:
_remove_solids.add((x, y))
_ground_tiles.add((x, y))
_solids = _solids - _remove_solids
for x in range(width):
for y in range(height):
if (x, y) in _solids:
continue
_ground_tiles.add((x, y))
#This generates the outside walls
for pos in _solids:
_tile = tiles.wooden_fence(pos[0], pos[1])
_tile_map[pos[1]][pos[0]] = _tile
_weight_map[pos[1]][pos[0]] = _tile['w']
_ground_tiles = _ground_tiles - _windows
for x, y in _ground_tiles - _floor:
_tile = tiles.grass(x, y)
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
mapgen.build_node_grid(_node_grid, _solids)
_floor.update(_windows)
return width, height, _node_grid, mapgen.NODE_SETS.copy(
), _weight_map, _tile_map, _solids, {}, _trees, _floor, _lights, _spawns
import libtcodpy as libtcod
import math
import textwrap
import game_settings as opt
import shelve
color_noise = libtcod.noise_new(2)
color_dark_wall = libtcod.Color(31, 31, 39)
bgcolor_dark_wall = libtcod.Color(31, 31, 39)
color_light_wall = libtcod.Color(80,80,77)
bgcolor_light_wall = libtcod.Color(50,50,48)
color_dark_ground = libtcod.Color(3, 3, 5)
bgcolor_dark_ground = libtcod.Color(20, 20, 26)
color_light_ground = libtcod.Color(80,80,77)
bgcolor_light_ground = libtcod.Color(32,32,29)
# TODO
# Generalize map code.
# Starting with Tile, I added four new options. default_fg, default_bg, default_char, and tile_name
# I will probably set something up so instead of setting tiles to blocked to determine if they're a wall,
# I'll instead just set the tile's tile_name to 'wall'
# When rendering, Instead of checking if it's blocked, I will just check for 'wall' or 'floor'
class Tile:
# def __init__(self, blocked, block_sight = None):
# self.blocked = blocked
# self.explored = False
def __init__(self, blocked, block_sight = None,
# light_fg=libtcod.red,
self.x = x
self.y = y
self.con = libtcod.console_new(self.width,self.height)
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 45
GAME_WIDTH = 55
GAME_HEIGHT = 30
MSG_WIDTH = GAME_WIDTH
MSG_HEIGHT = SCREEN_HEIGHT - GAME_HEIGHT - 1
LIMIT_FPS = 40
noise1d = libtcod.noise_new(1)
font = os.path.join('data', 'fonts', 'dejavu12x12_gs_tc.png')
libtcod.console_set_custom_font(font, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
torchconst = 0.0
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'Rogue Operative', False)
libtcod.sys_set_fps(LIMIT_FPS)
libtcod.sys_set_renderer(libtcod.RENDERER_SDL) # stick with SDL for now until other renderers are more stable
viewport = console(GAME_WIDTH,GAME_HEIGHT,0,0)
libtcod.console_set_default_foreground(viewport.con, libtcod.white)
message = console(MSG_WIDTH, MSG_HEIGHT,0,GAME_HEIGHT+1)
libtcod.console_set_default_foreground(message.con, libtcod.white)
################################################################################
# Map
################################################################################
MAP_WIDTH = 500
MAP_HEIGHT = 500
ROOM_MAX_SIZE = 20
ROOM_MIN_SIZE = 10
MAX_ROOMS = 450
MAX_ROOM_MONSTERS = 3
MAX_ROOM_ITEMS = 3
# Noise for generating terrain
height_map = libtcod.noise_new(2)
color_dark_wall = libtcod.Color(0, 0, 100)
color_light_wall = libtcod.Color(130, 110, 50)
color_dark_ground = libtcod.Color(50, 50, 150)
color_light_ground = libtcod.Color(200, 180, 50)
class Tile:
#a tile of the map and its properties
def __init__(self, blocked, data, block_sight = None, tile_type=None):
self.blocked = blocked
self.tile_type = tile_type
self.data = data
#by default, if a tile is blocked, it also blocks sight
if block_sight is None: block_sight = blocked
def create_map():
_grid = world_strategy.MAP['grid']
_color_map = world_strategy.MAP['color_map']
_ownable_plots = set()
_banned_plots = set()
#Mountains
_noise = tcod.noise_new(3)
_zoom = 1.25
_c_pos = constants.STRAT_MAP_WIDTH/2, constants.STRAT_MAP_HEIGHT/2
_solids = set()
for y in range(0, constants.STRAT_MAP_HEIGHT):
for x in range(0, constants.STRAT_MAP_WIDTH):
_m_x = x / constants.MAP_CELL_SPACE
_m_y = y / constants.MAP_CELL_SPACE
_m_x = numbers.clip(_m_x, 1, (constants.STRAT_MAP_WIDTH/constants.MAP_CELL_SPACE) - 2)
_m_y = numbers.clip(_m_y, 1, (constants.STRAT_MAP_HEIGHT/constants.MAP_CELL_SPACE) - 2)
_c_mod = numbers.float_distance(_c_pos, (x, y))/max([constants.STRAT_MAP_WIDTH/2, constants.STRAT_MAP_HEIGHT/2])
_noise_values = [(_zoom * x / (constants.STRAT_MAP_WIDTH)),
(_zoom * y / (constants.STRAT_MAP_HEIGHT))]
_height = tcod.noise_get_turbulence(_noise, _noise_values, tcod.NOISE_SIMPLEX) * _c_mod
_char = ' '
#Mountain
if _height > .55:
_color_map[x, y] = random.choice([constants.DARKER_GRAY_1,
constants.DARKER_GRAY_2,
constants.DARKER_GRAY_3])
_grid[_m_x, _m_y]['is_ownable'] = False
_banned_plots.add((_m_x, _m_y))
_c_1 = int(round(_color_map[x, y][0] * (1.8 * _height)))
_c_2 = int(round(_color_map[x, y][1] * (1.8 * _height)))
_c_3 = int(round(_color_map[x, y][2] * (1.8 * _height)))
else:
_color_map[x, y] = random.choice([constants.FOREST_GREEN_1,
constants.FOREST_GREEN_2,
constants.FOREST_GREEN_3])
_ownable_plots.add((_m_x, _m_y))
if _height <= .2:
_char = random.choice([',', '.', '\'', ' ' * (1 + (20 * int(round(_height))))])
_height -= .1
_c_1 = int(round(_color_map[x, y][0] * (.7 + _height * 2.8)))
_c_2 = int(round(_color_map[x, y][1] * (1.0 + _height * .9)))
_c_3 = int(round(_color_map[x, y][2] * (.75 + _height * 1.2)))
display._set_char('map', x, y, _char, (int(round(_c_1 * .8)), int(round(_c_2 * .8)), int(round(_c_3 * .8))), (_c_1, _c_2, _c_3))
_solids = [(x, y) for x, y in list(_banned_plots)]
world_strategy.MAP['astar_map'] = pathfinding.setup(constants.STRAT_MAP_WIDTH/constants.MAP_CELL_SPACE,
constants.STRAT_MAP_HEIGHT/constants.MAP_CELL_SPACE,
_solids)
return list(_ownable_plots - _banned_plots)
MAP_WIDTH = 80
MAP_HEIGHT = 45
# parameters for dungeon generator
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
FOV_ALGO = 0 # default FOV algorithm
FOV_LIGHT_WALLS = True # light walls or not
FOV_TORCH = True # Set torch FX
FOV_TORCHX = 0.0
FOV_NOISE = None
TORCH_RADIUS = 10
noise = libtcod.noise_new(2)
LIMIT_FPS = 20 # 20 frames-per-second maximum
color_dark_ground = libtcod.Color(53, 53, 53)
color_dark_wall = libtcod.Color(25, 25, 25)
color_light_wall = libtcod.Color(153, 153, 102)
color_light_ground = libtcod.Color(102, 102, 102)
class Tile:
# a tile of the map and its properties
def __init__(self, blocked, block_sight=None):
self.blocked = blocked
# all tiles start unexplored
def activate(zone_id):
global ACTIVE_ZONE
ACTIVE_ZONE = zone_id
_zone = ZONES[zone_id]
_noise = tcod.noise_new(2)
logging.info('Bringing zone \'%s\' online...' % _zone['name'])
_zone['astar_map'] = pathfinding.setup(_zone['width'], _zone['height'],
_zone['solids'])
_zone['los_map'] = mapgen.generate_los_map(_zone['width'], _zone['height'],
_zone['solids'])
display.create_surface('tiles',
width=_zone['width'],
height=_zone['height'])
maps.render_map(_zone['tile_map'], _zone['width'], _zone['height'])
post_processing.start()
events.register_event('logic', post_processing.tick_sun)
_static_lighting = display.create_shader(_zone['width'],
_zone['height'],
start_offset=1)
_zone['shaders'].append(
post_processing.generate_shadow_map(_zone['width'], _zone['height'],
_zone['solids'], _zone['trees'],
_zone['inside']))
_zone['shaders'].append(
post_processing.generate_light_map(_zone['width'], _zone['height'],
_zone['solids'], _zone['trees']))
_zone['light_maps']['static_lighting'] = _static_lighting
_zone['shaders'].append(_static_lighting)
_noise = tcod.noise_new(3)
_zoom = 2.0
_zone['fader'] = display.create_shader(_zone['width'], _zone['height'])
_shader = display.create_shader(_zone['width'], _zone['height'])
for y in range(0, _zone['height']):
for x in range(0, _zone['width']):
if (x, y) in _zone['inside']:
_height = .75
else:
_noise_values = [(_zoom * x / _zone['width']),
(_zoom * y / _zone['height'])]
_height = .35 + numbers.clip(
tcod.noise_get_turbulence(_noise, _noise_values,
tcod.NOISE_SIMPLEX), .35, 1)
_shader[0][y, x] = 1.3 * _height
_shader[1][y, x] = 1.3 * _height
_shader[2][y, x] = 1.1 * _height
_zone['shaders'].append(_shader)
for light in _zone['lights']:
effects.light(light[0],
light[1],
light[2],
r=light[3],
g=light[4],
b=light[5],
light_map='static_lighting')
#if not '--no-fx' in sys.argv:
# post_processing.run(time=8,
# repeat=-1,
# repeat_callback=lambda _: post_processing.post_process_clouds(constants.MAP_VIEW_WIDTH,
# constants.MAP_VIEW_HEIGHT,
# 8,
# _noise,
# _zone['inside']))
post_processing.run(
time=0,
repeat=-1,
repeat_callback=lambda _: post_processing.post_process_lights())
#post_processing.run(time=0,
# repeat=-1,
# repeat_callback=lambda _: post_processing.sunlight())
camera.set_limits(0, 0, _zone['width'] - constants.MAP_VIEW_WIDTH,
_zone['height'] - constants.MAP_VIEW_HEIGHT)
logging.info('Zone \'%s\' is online' % _zone['name'])
def create():
display.create_surface('background')
display.create_surface('text')
display.blit_background('background')
roll()
NOISE = tcod.noise_new(2,
h=tcod.NOISE_DEFAULT_HURST,
random=tcod.random_new())
for y in range(0, constants.WINDOW_HEIGHT):
for x in range(0, constants.WINDOW_WIDTH):
_noise_values = [(ZOOM * x / (constants.WINDOW_WIDTH)),
(ZOOM * y / (constants.WINDOW_HEIGHT))]
_height = 1 - tcod.noise_get_turbulence(NOISE, _noise_values,
tcod.NOISE_SIMPLEX)
_dist_to_crosshair = 30
_crosshair_mod = abs((_dist_to_crosshair - 1))
if _height > .4:
_height = (_height - .4) / .4
_r, _g, _b = numbers.clip(30 * _height, 20,
255), 50 * _height, numbers.clip(
30 * _height, 30, 255)
else:
_r, _g, _b = 20, 0, 30
_r += 30 # * _crosshair_mod
if x < SIDEBAR_WIDTH:
if y < 7:
_r = numbers.interp(_r, .0, .4)
_g = numbers.interp(_g, .0, .4)
_b = numbers.interp(_b, .0, .4)
elif y < 43:
_r = numbers.interp(_r, .0, .6)
_g = numbers.interp(_g, .0, .6)
_b = numbers.interp(_b, .0, .6)
elif y < constants.WINDOW_HEIGHT:
_r = numbers.interp(_r, 1, .7)
_g = numbers.interp(_g, 1, .7)
_b = numbers.interp(_b, 1, .7)
else:
_r = (int(round(_r * 1.0)))
_g = (int(round(_g * .2)))
_b = (int(round(_b * .2)))
if x > SIDEBAR_WIDTH + 3 and x < constants.WINDOW_WIDTH - 6:
if y > 18 and y < 36:
_r = numbers.interp(_r, 255, .1)
_g = numbers.interp(_g, 255, .1)
_b = numbers.interp(_b, 255, .1)
if x > SIDEBAR_WIDTH + 3 and x < constants.WINDOW_WIDTH - 6:
if y > 10 and y < 16:
_r = numbers.interp(_r, .0, .4)
_g = numbers.interp(_g, .0, .4)
_b = numbers.interp(_b, .0, .4)
display._set_char('background', x, y, ' ', (0, 0, 0), (_r, _g, _b))
import libtcodpy as libtcod
import math
import textwrap
import game_settings as opt
import shelve
color_noise = libtcod.noise_new(2)
color_dark_wall = libtcod.Color(31, 31, 39)
bgcolor_dark_wall = libtcod.Color(31, 31, 39)
color_light_wall = libtcod.Color(80, 80, 77)
bgcolor_light_wall = libtcod.Color(50, 50, 48)
color_dark_ground = libtcod.Color(3, 3, 5)
bgcolor_dark_ground = libtcod.Color(20, 20, 26)
color_light_ground = libtcod.Color(80, 80, 77)
bgcolor_light_ground = libtcod.Color(32, 32, 29)
# TODO
# Generalize map code.
# Starting with Tile, I added four new options. default_fg, default_bg, default_char, and tile_name
# I will probably set something up so instead of setting tiles to blocked to determine if they're a wall,
# I'll instead just set the tile's tile_name to 'wall'
# When rendering, Instead of checking if it's blocked, I will just check for 'wall' or 'floor'
class Tile:
# def __init__(self, blocked, block_sight = None):
# self.blocked = blocked
# self.explored = False
def __init__(
self,
blocked,
#!/usr/bin/python
import math
import libtcodpy as libtcod
# size of the heightmap
HM_WIDTH=80
HM_HEIGHT=80
rnd=libtcod.random_new()
noise=libtcod.noise_new(2,libtcod.NOISE_DEFAULT_HURST,libtcod.NOISE_DEFAULT_LACUNARITY,rnd)
def addHill(hm,nbHill,baseRadius,radiusVar,height) :
for i in range(nbHill) :
hillMinRadius=baseRadius*(1.0-radiusVar)
hillMaxRadius=baseRadius*(1.0+radiusVar)
radius = libtcod.random_get_float(rnd,hillMinRadius, hillMaxRadius)
theta = libtcod.random_get_float(rnd,0.0, 6.283185) # between 0 and 2Pi
dist = libtcod.random_get_float(rnd,0.0, float(min(HM_WIDTH,HM_HEIGHT))/2 - radius)
xh = int(HM_WIDTH/2 + math.cos(theta) * dist)
yh = int(HM_HEIGHT/2 + math.sin(theta) * dist)
libtcod.heightmap_add_hill(hm,float(xh),float(yh),radius,height)
# 3x3 kernel for smoothing operations
smoothKernelSize=9
smoothKernelDx=[-1,0,1,-1,0,1,-1,0,1]
smoothKernelDy=[-1,-1,-1,0,0,0,1,1,1]
smoothKernelWeight=[1.0,2.0,1.0,2.0,20.0,2.0,1.0,2.0,1.0]
# function building the heightmap
def buildMap(hm) :
libtcod.heightmap_add_fbm(hm,noise,3.83,3.83,400,0,4.93,1,0.35)
libtcod.heightmap_normalize(hm)
def head(l):
if len(l) == 0:
return None
def generate(width, height):
_weight_map, _tile_map, _solids, _node_grid = mapgen.create_map(
width, height)
_zoom = .95
_noise = tcod.noise_new(3)
_low_grass = 25
_fsl = {}
_building_space = set()
_walls = set()
_possible_trees = set()
_river_start_x = random.randint(int(round(width * .35)),
int(round(width * .65)))
_river_start_y = 0 #random.randint(int(round(height * .15)), int(round(height * .85)))
_x = _river_start_x
_y = _river_start_y
_px, _py = _river_start_x, _river_start_y
_river_direction = 270
_turn_rate = random.randint(-1, 1)
_river_tiles = set()
_river_size = random.randint(7, 10)
_ground_tiles = set()
_possible_camps = set()
while 1:
for i in range(4, 10):
for __x, __y in shapes.circle(_x, _y, _river_size):
if __x < 0 or __y < 0 or __x >= width or __y >= height or (
__x, __y) in _solids:
continue
_river_tiles.add((__x, __y))
_tile = tiles.swamp_water(__x, __y)
_tile_map[__y][__x] = _tile
_weight_map[__y][__x] = _tile['w']
_river_direction += _turn_rate
_xv, _yv = numbers.velocity(_river_direction, 1)
_px += _xv
_py += _yv
_x = int(round(_px))
_y = int(round(_py))
if _x < 0 or _y < 0 or _x >= width or _y >= height or (
_x, _y) in _solids:
break
if _x < 0 or _y < 0 or _x >= width or _y >= height:
break
_turn_rate = random.uniform(-2.5, 2.5)
_river_size = numbers.clip(_river_size + random.randint(-1, 1), 7, 10)
for y in range(height):
for x in range(width):
if (x, y) in _river_tiles:
continue
_tile = tiles.grass(x, y)
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
_ground_tiles.add((x, y))
tcod.noise_set_type(_noise, tcod.NOISE_WAVELET)
for y in range(height):
for x in range(width):
if (x, y) in _river_tiles:
continue
_noise_values = [(_zoom * x / (constants.MAP_VIEW_WIDTH)),
(_zoom * y / (constants.MAP_VIEW_HEIGHT))]
_noise_value = 100 * tcod.noise_get_turbulence(
_noise, _noise_values, tcod.NOISE_WAVELET)
if _low_grass <= _noise_value <= 100:
_tile = tiles.tall_grass(x, y)
if _noise_value >= 40:
if not x < width * .15 and not x > width * .85 and not y < height * .15 and not y > height * .85:
_possible_camps.add((x, y))
if random.uniform(0, 1) > .5:
_possible_trees.add((x, y))
elif _noise_value >= _low_grass - 10 and 10 * random.uniform(
0, 1) > _low_grass - _noise_value:
_tile = tiles.grass(x, y)
else:
_tile = tiles.rock(x, y)
_solids.add((x, y))
_tile_map[y][x] = _tile
_weight_map[y][x] = _tile['w']
_trees = {}
_tree_plots = _possible_trees - _solids - _river_tiles
_used_trees = random.sample(
_tree_plots,
numbers.clip(int(round((width * height) * .002)), 0, len(_tree_plots)))
for x, y in _used_trees:
_size = random.randint(1, 3)
for _x, _y in shapes.circle(x, y, _size):
if _x < 0 or _y < 0 or _x >= width or _y >= height or (
_x, _y) in _solids:
break
_tile = tiles.tree(_x, _y)
_weight_map[_y][_x] = _tile['w']
_tile_map[_y][_x] = _tile
_trees[_x, _y] = random.uniform(2, 3.5) * _size
_solids.add((_x, _y))
_ground_tiles = _ground_tiles - _solids
_plot_pole_x, _plot_pole_y = width / 2, height / 2
_bushes = random.sample(
_ground_tiles,
numbers.clip(int(round((width * height) * .0003)), 0,
len(_ground_tiles)))
_camps = set()
while len(_possible_camps):
_camp_1 = random.choice(list(_possible_camps))
_possible_camps.remove(_camp_1)
_camps.add(_camp_1)
for camp_2 in _possible_camps.copy():
_dist = numbers.distance(_camp_1, camp_2)
if _dist <= 250:
_possible_camps.remove(camp_2)
for x, y in _bushes:
_walker_x = x
_walker_y = y
_last_dir = -2, -2
for i in range(random.randint(10, 15)):
_tile = tiles.tree(_walker_x, _walker_y)
_weight_map[_walker_y][_walker_x] = _tile['w']
_tile_map[_walker_y][_walker_x] = _tile
_dir = random.randint(-1, 1), random.randint(-1, 1)
_n_x = _walker_x + _dir[0]
_n_y = _walker_y + _dir[1]
if _n_x < 0 or _n_y < 0 or _n_x >= width or _n_y >= height or (
_n_x, _n_y) in _solids:
break
_last_dir = _dir[0] * -1, _dir[0] * -1
_walker_x = _n_x
_walker_y = _n_y
_camp_info = {}
for c_x, c_y in _camps:
_building_walls = random.sample(['north', 'south', 'east', 'west'],
random.randint(2, 3))
_broken_walls = random.sample(
_building_walls,
numbers.clip(random.randint(0, 3), 0, len(_building_walls)))
_camp = {'center': (c_x, c_y)}
_camp_ground = []
for y in range(-10, 10 + 1):
for x in range(-10, 10 + 1):
_x = x + c_x
_y = y + c_y
if (_x, _y) in _solids or (_x, _y) in _river_tiles:
continue
if (x == -10 and 'west' in _building_walls) or (
y == -10 and 'north' in _building_walls) or (
x == 10 and 'east' in _building_walls) or (
y == 10 and 'south' in _building_walls):
if x == -10 and 'west' in _building_walls and 'west' in _broken_walls and random.uniform(
0, 1) > .75:
continue
if x == 10 and 'east' in _building_walls and 'east' in _broken_walls and random.uniform(
0, 1) > .75:
continue
if y == -10 and 'north' in _building_walls and 'north' in _broken_walls and random.uniform(
0, 1) > .75:
continue
if y == 10 and 'south' in _building_walls and 'south' in _broken_walls and random.uniform(
0, 1) > .75:
continue
_tile = tiles.wooden_fence(_x, _y)
_weight_map[_y][_x] = _tile['w']
_tile_map[_y][_x] = _tile
_solids.add((_x, _y))
elif (x > -10 and x <= 10) and (y > -10 and y <= 10):
_camp_ground.append((_x, _y))
_camp['ground'] = _camp_ground[:]
_camp_info[c_x, c_y] = _camp
mapgen.build_node_grid(_node_grid, _solids)
for c_x, c_y in _camps:
mapgen.add_plot_pole(c_x, c_y, 40, _solids)
_fsl = {
'Terrorists': {
'bases': 1,
'squads': 0,
'trader': False,
'type': life.human_runner
}
}
# #'Militia': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.human_bandit},
# 'Wild Dogs': {'bases': 0, 'squads': 1, 'trader': False, 'type': life.wild_dog}}
return width, height, _node_grid, mapgen.NODE_SETS.copy(
), _weight_map, _tile_map, _solids, _fsl, _trees, _building_space - _walls
def MasterWorldGen(
): #------------------------------------------------------- * MASTER GEN * -------------------------------------------------------------
print ' * World Gen START * '
starttime = time.time()
#Heightmap
hm = libtcod.heightmap_new(WORLD_WIDTH, WORLD_HEIGHT)
for i in range(50):
libtcod.heightmap_add_hill(
hm, randint(WORLD_WIDTH / 10, WORLD_WIDTH - WORLD_WIDTH / 10),
randint(WORLD_HEIGHT / 10, WORLD_HEIGHT - WORLD_HEIGHT / 10),
randint(12, 16), randint(6, 10))
print '- Main Hills -'
for i in range(200):
libtcod.heightmap_add_hill(
hm, randint(WORLD_WIDTH / 10, WORLD_WIDTH - WORLD_WIDTH / 10),
randint(WORLD_HEIGHT / 10, WORLD_HEIGHT - WORLD_HEIGHT / 10),
randint(2, 4), randint(6, 10))
print '- Small Hills -'
libtcod.heightmap_normalize(hm, 0.0, 1.0)
noisehm = libtcod.heightmap_new(WORLD_WIDTH, WORLD_HEIGHT)
noise2d = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(noisehm, noise2d, 4, 4, 0, 0, 32, 1, 1)
libtcod.heightmap_normalize(noisehm, 0.0, 1.0)
libtcod.heightmap_multiply_hm(hm, noisehm, hm)
print '- Apply Simplex -'
PoleGen(hm, 0)
print '- South Pole -'
PoleGen(hm, 1)
print '- North Pole -'
TectonicGen(hm, 0)
TectonicGen(hm, 1)
print '- Tectonic Gen -'
libtcod.heightmap_rain_erosion(hm, WORLD_WIDTH * WORLD_HEIGHT, 0.07, 0, 0)
print '- Erosion -'
libtcod.heightmap_clamp(hm, 0.0, 1.0)
#Temperature
temp = libtcod.heightmap_new(WORLD_WIDTH, WORLD_HEIGHT)
Temperature(temp, hm)
libtcod.heightmap_normalize(temp, 0.0, 0.8)
print '- Temperature Calculation -'
#Precipitation
preciphm = libtcod.heightmap_new(WORLD_WIDTH, WORLD_HEIGHT)
Percipitaion(preciphm, temp)
libtcod.heightmap_normalize(preciphm, 0.0, 0.8)
print '- Percipitaion Calculation -'
#Drainage
drainhm = libtcod.heightmap_new(WORLD_WIDTH, WORLD_HEIGHT)
drain = libtcod.noise_new(2, libtcod.NOISE_DEFAULT_HURST,
libtcod.NOISE_DEFAULT_LACUNARITY)
libtcod.heightmap_add_fbm(drainhm, drain, 2, 2, 0, 0, 32, 1, 1)
libtcod.heightmap_normalize(drainhm, 0.0, 0.8)
print '- Drainage Calculation -'
# VOLCANISM - RARE AT SEA FOR NEW ISLANDS (?) RARE AT MOUNTAINS > 0.9 (?) RARE AT TECTONIC BORDERS (?)
elapsed_time = time.time() - starttime
print ' * World Gen DONE * in: ', elapsed_time, ' seconds'
#Initialize Tiles with Map values
World = [[0 for y in range(WORLD_HEIGHT)]
for x in range(WORLD_WIDTH)] #100x100 array
for x in xrange(WORLD_WIDTH):
for y in xrange(WORLD_HEIGHT):
World[x][y] = Tile(libtcod.heightmap_get_value(hm, x, y),
libtcod.heightmap_get_value(temp, x, y),
libtcod.heightmap_get_value(preciphm, x, y),
libtcod.heightmap_get_value(drainhm, x, y), 0)
print '- Tiles Initialized -'
#Prosperity
Prosperity(World)
print '- Prosperity Calculation -'
#Biome info to Tile
for x in xrange(WORLD_WIDTH):
for y in xrange(WORLD_HEIGHT):
if World[x][y].height > 0.2:
World[x][y].biomeID = 3
if randint(1, 10) < 3:
World[x][y].biomeID = 5
if World[x][y].height > 0.4:
World[x][y].biomeID = 14
if randint(1, 10) < 3:
World[x][y].biomeID = 5
if World[x][y].height > 0.5:
World[x][y].biomeID = 8
if randint(1, 10) < 3:
World[x][y].biomeID = 14
if World[x][y].temp <= 0.5 and World[x][y].precip >= 0.5:
World[x][y].biomeID = 5
if randint(1, 10) < 3:
World[x][y].biomeID = 14
if World[x][y].temp >= 0.5 and World[x][y].precip >= 0.7:
World[x][y].biomeID = 6
if World[x][y].precip >= 0.7 and World[x][
y].height > 0.2 and World[x][y].height <= 0.4:
World[x][y].biomeID = 2
if World[x][y].temp > 0.75 and World[x][y].precip < 0.35:
World[x][y].biomeID = 4
if World[x][y].temp <= 0.22 and World[x][y].height > 0.2:
World[x][y].biomeID = randint(11, 13)
if World[x][y].temp <= 0.3 and World[x][y].temp > 0.2 and World[x][
y].height > 0.2 and World[x][y].precip >= 0.6:
World[x][y].biomeID = 7
if World[x][y].height > 0.75:
World[x][y].biomeID = 9
if World[x][y].height > 0.999:
World[x][y].biomeID = 10
if World[x][y].height <= 0.2:
World[x][y].biomeID = 0
if World[x][y].height <= 0.1:
World[x][y].biomeID = 0
print '- BiomeIDs Atributed -'
#River Gen
for x in range(5):
RiverGen(World)
print '- River Gen -'
#Free Heightmaps
libtcod.heightmap_delete(hm)
libtcod.heightmap_delete(temp)
libtcod.heightmap_delete(noisehm)
print ' * Biomes/Rivers Sorted *'
return World
################################################################################
# Map
################################################################################
MAP_WIDTH = 500
MAP_HEIGHT = 500
ROOM_MAX_SIZE = 20
ROOM_MIN_SIZE = 10
MAX_ROOMS = 450
MAX_ROOM_MONSTERS = 3
MAX_ROOM_ITEMS = 3
# Noise for generating terrain
height_map = libtcod.noise_new(2)
color_dark_wall = libtcod.Color(0, 0, 100)
color_light_wall = libtcod.Color(130, 110, 50)
color_dark_ground = libtcod.Color(50, 50, 150)
color_light_ground = libtcod.Color(200, 180, 50)
class Tile:
#a tile of the map and its properties
def __init__(self, blocked, data, block_sight=None, tile_type=None):
self.blocked = blocked
self.tile_type = tile_type
self.data = data
#by default, if a tile is blocked, it also blocks sight
