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 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 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 __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 __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 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 _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 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 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 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 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 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 make_bare_surface_map(player=None): """ Creates a map which is open by default, and then filled with boulders, mesas and rocks. Uses a 2D noise generator. The map has an impenetrable border. """ objects_for_this_map = [] if player is None: #Creating the object representing the player: fighter_component = Fighter(hp=30, defense=2, power=5, xp=0, death_function=player_death) #creating the fighter aspect of the player player = GamePiece(0, 0, 219, 'player', libtcod.white, blocks=False, fighter=fighter_component, speed=PLAYER_SPEED) player.level = 1 objects_for_this_map.append(player) else: # This must not be a new game. We need to put the pre-existing player into the list and later give them an # appropriate spot in the map to have spatial translation continuity. objects_for_this_map.append(player) noise2d = libtcod.noise_new(2) #create a 2D noise generator libtcod.noise_set_type(noise2d, libtcod.NOISE_SIMPLEX) #tell it to use simplex noise for higher contrast # Create the map with a default tile choice of empty unblocked squares. newmap = [[ Tile(blocked=False, block_sight=False, char=' ', fore=color_ground, back=color_ground) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH) ] #Put a border around the map so the characters can't go off the edge of the world for x in range(0, MAP_WIDTH): newmap[x][0].blocked = True newmap[x][0].block_sight = True newmap[x][0].mapedge = True newmap[x][0].fore = color_wall newmap[x][0].back = color_wall newmap[x][MAP_HEIGHT-1].blocked = True newmap[x][MAP_HEIGHT-1].block_sight = True newmap[x][MAP_HEIGHT-1].mapedge = True newmap[x][MAP_HEIGHT-1].fore = color_wall newmap[x][MAP_HEIGHT-1].back = color_wall for y in range(0, MAP_HEIGHT): newmap[0][y].blocked = True newmap[0][y].block_sight = True newmap[0][y].mapedge = True newmap[0][y].fore = color_wall newmap[0][y].back = color_wall newmap[MAP_WIDTH-1][y].blocked = True newmap[MAP_WIDTH-1][y].block_sight = True newmap[MAP_WIDTH-1][y].mapedge = True newmap[MAP_WIDTH-1][y].fore = color_wall newmap[MAP_WIDTH-1][y].back = color_wall # Create natural looking landscape for x in range(1, MAP_WIDTH-1): for y in range(1, MAP_HEIGHT-1): if libtcod.noise_get_turbulence(noise2d, [x, y], 128.0, libtcod.NOISE_SIMPLEX) < 0.4: #Turbulent simplex noise returns values between 0.0 and 1.0, with many values greater than 0.9. newmap[x][y].blocked = True newmap[x][y].block_sight = True newmap[x][y].fore = color_wall newmap[x][y].back = color_wall # Scatter debris around the map to add flavor: place_junk(newmap) # Choose a spot for the player to start player.x, player.y = choose_random_unblocked_spot(newmap) return newmap, objects_for_this_map
def make_surface_map(player=None): """ Creates a map which is open by default, and then filled with boulders, mesas and buildings. Uses a 2D noise generator. The map has an impenetrable border. """ objects_for_this_map = [] new_objects = [] more_objects = [] if player is None: #Creating the object representing the player: fighter_component = Fighter(hp=30, defense=2, power=5, xp=0, death_function=player_death) #creating the fighter aspect of the player player = GamePiece(0, 0, 219, 'player', libtcod.white, blocks=False, fighter=fighter_component, speed=PLAYER_SPEED) player.level = 1 objects_for_this_map.append(player) else: # This must not be a new game. We need to put the pre-existing player into the list and later give them an # appropriate spot in the map to have spatial translation continuity. objects_for_this_map.append(player) noise2d = libtcod.noise_new(2) #create a 2D noise generator libtcod.noise_set_type(noise2d, libtcod.NOISE_SIMPLEX) #tell it to use simplex noise for higher contrast # Create the map with a default tile choice of empty unblocked squares. newmap = [[ Tile(blocked=False, block_sight=False, char=' ', fore=color_ground, back=color_ground) for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH) ] #Put a border around the map so the characters can't go off the edge of the world for x in range(0, MAP_WIDTH): newmap[x][0].blocked = True newmap[x][0].block_sight = True newmap[x][0].mapedge = True newmap[x][0].fore = color_wall newmap[x][0].back = color_wall newmap[x][MAP_HEIGHT-1].blocked = True newmap[x][MAP_HEIGHT-1].block_sight = True newmap[x][MAP_HEIGHT-1].mapedge = True newmap[x][MAP_HEIGHT-1].fore = color_wall newmap[x][MAP_HEIGHT-1].back = color_wall for y in range(0, MAP_HEIGHT): newmap[0][y].blocked = True newmap[0][y].block_sight = True newmap[0][y].mapedge = True newmap[0][y].fore = color_wall newmap[0][y].back = color_wall newmap[MAP_WIDTH-1][y].blocked = True newmap[MAP_WIDTH-1][y].block_sight = True newmap[MAP_WIDTH-1][y].mapedge = True newmap[MAP_WIDTH-1][y].fore = color_wall newmap[MAP_WIDTH-1][y].back = color_wall # Create natural looking landscape for x in range(1, MAP_WIDTH-1): for y in range(1, MAP_HEIGHT-1): if libtcod.noise_get_turbulence(noise2d, [x, y], 128.0, libtcod.NOISE_SIMPLEX) < 0.4: #Turbulent simplex noise returns values between 0.0 and 1.0, with many values greater than 0.9. newmap[x][y].blocked = True newmap[x][y].block_sight = True newmap[x][y].fore = color_wall newmap[x][y].back = color_wall # Place buildings buildings = [] num_buildings = 0 for r in range(MAX_BUILDINGS): w = libtcod.random_get_int(0, BUILDING_MIN_SIZE, BUILDING_MAX_SIZE) h = libtcod.random_get_int(0, BUILDING_MIN_SIZE, BUILDING_MAX_SIZE) x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1) y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1) new_building = Rect(x, y, w, h) create_building(newmap, new_building) buildings.append(new_building) num_buildings += 1 #Create stairs in the last building if num_buildings == MAX_BUILDINGS: new_x, new_y = new_building.center() stairs = GamePiece(new_x, new_y, '>', 'stairs', libtcod.white, always_visible=True) objects_for_this_map.append(stairs) #stairs.send_to_back(newmap.objects) #so that it gets drawn below NPCs. I commented this out because # it should be at the end anyway, since its being appended. #Put doors in buildings. Have to do this AFTER they are built or later ones will overwrite earlier ones # door_chances = { 'left': 25, 'right': 25, 'top': 25, 'bottom': 25 } for place in buildings: # num_doors = libtcod.random_get_int(0, 2, 4) # for case in switch(num_doors): # if case(2): # choice = random_choice(door_chances) doorx, doory = place.middle_of_wall('left') if newmap[doorx][doory].blocked and not newmap[doorx][doory].mapedge: newmap[doorx][doory].char = LEFT_DOOR newmap[doorx][doory].blocked = False newmap[doorx][doory].fore = libtcod.white newmap[doorx][doory].back = libtcod.grey doorx, doory = place.middle_of_wall('top') if newmap[doorx][doory].blocked and not newmap[doorx][doory].mapedge: newmap[doorx][doory].char = TOP_DOOR newmap[doorx][doory].blocked = False newmap[doorx][doory].fore = libtcod.white newmap[doorx][doory].back = libtcod.grey doorx, doory = place.middle_of_wall('right') if newmap[doorx][doory].blocked and not newmap[doorx][doory].mapedge: newmap[doorx][doory].char = RIGHT_DOOR newmap[doorx][doory].blocked = False newmap[doorx][doory].fore = libtcod.white newmap[doorx][doory].back = libtcod.grey doorx, doory = place.middle_of_wall('bottom') if newmap[doorx][doory].blocked and not newmap[doorx][doory].mapedge: newmap[doorx][doory].char = BOTTOM_DOOR newmap[doorx][doory].blocked = False newmap[doorx][doory].fore = libtcod.white newmap[doorx][doory].back = libtcod.grey more_objects = place_objects(newmap, place) #add some contents to this room if more_objects is not None: for item in more_objects: new_objects.append(item) # Scatter debris around the map to add flavor: place_junk(newmap) # Choose a spot for the player to start player.x, player.y = choose_random_unblocked_spot(newmap) for item in new_objects: objects_for_this_map.append(item) return newmap, objects_for_this_map
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)