def light(x, y, brightness, r=1., g=1., b=1., light_map=None): if '--no-fx' in sys.argv: return if light_map: _active_light_maps = zones.get_active_light_maps() _light_map = _active_light_maps[light_map] else: _light_map = post_processing.get_light_map() _width, _height = zones.get_active_size() for _x, _y in shapes.circle(x, y, brightness): if _x < 0 or _x >= _width or _y < 0 or _y >= _height: continue _brightness = 1 - ((numbers.float_distance((x, y), (_x, _y)) - 1.0) / float(brightness)) _r = numbers.clip(2 * (_brightness * r), 1, 4) _g = numbers.clip(2 * (_brightness * g), 1, 4) _b = numbers.clip(2 * (_brightness * b), 1, 4) _min_r = min(_light_map[0][_y, _x], _r) _max_r = max(_light_map[0][_y, _x], _r) _min_g = min([_light_map[1][_y, _x], _g]) _max_g = max([_light_map[1][_y, _x], _g]) _min_b = min([_light_map[2][_y, _x], _b]) _max_b = max([_light_map[2][_y, _x], _b]) _light_map[0][_y, _x] = numbers.interp(_min_r, _max_r, .5) _light_map[1][_y, _x] = numbers.interp(_min_g, _max_g, .5) _light_map[2][_y, _x] = numbers.interp(_min_b, _max_b, .5)
def explosion(x, y, size):
_solids = zones.get_active_solids({}, no_life=True)
for pos in shapes.circle_smooth(x, y, size + .1, 0.05):
_c_mod = 1 - (numbers.float_distance((x, y), pos) / size)
_c_mod_clip = numbers.clip(1 - numbers.float_distance((x, y), pos) / size, random.uniform(.3, .45), 1)
if pos in _solids or set(shapes.line((x, y), (int(round(pos[0])), int(round(pos[1]))))) & _solids:
continue
smoke(pos[0], pos[1], _c_mod_clip)
if random.uniform(0, 1) < numbers.clip(_c_mod, 0, .75) and not pos in _solids:
fire(pos[0], pos[1], _c_mod)
for i in range(random.randint(2 * size, 3*size)):
smoke_shooter(x, y, random.randint(0, 359))
light(x, y, random.randint(7, 9), r=2.5, g=1.5, b=1.5)
light(x, y, random.randint(13, 15), r=1.3, g=1.3, b=1.3)
def generate_shadow_map(width, height, solids, trees, inside):
global SHADOWS
SHADOWS = display.create_shader(width, height)
SHADOWS[0] += 1
SHADOWS[1] += 1
SHADOWS[2] += 1
_taken = set()
for x, y in solids:
if (x, y) in trees:
continue
for y1 in range(-3, 4):
for x1 in range(-3, 4):
if (x + x1,
y + y1) in solids or (x + x1, y + y1) in inside or (
x + x1, y + y1
) in _taken or x + x1 >= width or y + y1 >= height:
continue
_shadow = numbers.clip(
numbers.distance((x, y),
(x + x1, y + y1)) / 5.0, .25, .6) + .25
if _shadow < SHADOWS[0][y + y1][x + x1]:
SHADOWS[0][y + y1][x + x1] = _shadow
SHADOWS[1][y + y1][x + x1] = _shadow
SHADOWS[2][y + y1][x + x1] = _shadow
_taken = set()
for _x, _y in trees.keys():
_tree_size = float(trees[_x, _y])
for x, y in shapes.circle(_x, _y, int(_tree_size)):
if (x, y) in solids or x >= width or y >= height or x < 0 or y < 0:
continue
_distance = numbers.float_distance((x, y), (_x, _y)) * 1.25
_shadow = numbers.clip(1 - ((_distance / _tree_size) + .25), .1,
.9)
SHADOWS[0][y][x] = numbers.clip(SHADOWS[0][y][x] - _shadow, .45, 1)
SHADOWS[1][y][x] = numbers.clip(SHADOWS[1][y][x] - _shadow, .45, 1)
SHADOWS[2][y][x] = numbers.clip(SHADOWS[2][y][x] - _shadow, .45, 1)
return SHADOWS
def generate_shadow_map(width, height, solids, trees, inside): global SHADOWS SHADOWS = display.create_shader(width, height) SHADOWS[0] += 1 SHADOWS[1] += 1 SHADOWS[2] += 1 _taken = set() for x, y in solids: if (x, y) in trees: continue for y1 in range(-3, 4): for x1 in range(-3, 4): if (x+x1, y+y1) in solids or (x+x1, y+y1) in inside or (x+x1, y+y1) in _taken or x+x1 >= width or y+y1 >= height: continue _shadow = numbers.clip(numbers.distance((x, y), (x+x1, y+y1))/5.0, .25, .6) + .25 if _shadow < SHADOWS[0][y+y1][x+x1]: SHADOWS[0][y+y1][x+x1] = _shadow SHADOWS[1][y+y1][x+x1] = _shadow SHADOWS[2][y+y1][x+x1] = _shadow _taken = set() for _x, _y in trees.keys(): _tree_size = float(trees[_x, _y]) for x, y in shapes.circle(_x, _y, int(_tree_size)): if (x, y) in solids or x >= width or y >= height or x < 0 or y <0: continue _distance = numbers.float_distance((x, y), (_x, _y))*1.25 _shadow = numbers.clip(1 - ((_distance / _tree_size) + .25), .1, .9) SHADOWS[0][y][x] = numbers.clip(SHADOWS[0][y][x]-_shadow, .45, 1) SHADOWS[1][y][x] = numbers.clip(SHADOWS[1][y][x]-_shadow, .45, 1) SHADOWS[2][y][x] = numbers.clip(SHADOWS[2][y][x]-_shadow, .45, 1) return SHADOWS
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)
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 smoke_cloud(x, y, size, start_alpha=.0, decay_amount=1.0): for pos in shapes.circle_smooth(x, y, size + .1, 0.1): _c_mod = numbers.clip(1 - numbers.float_distance((x, y), pos) / size, start_alpha, 1) smoke(pos[0], pos[1], 1, start_amount=_c_mod, decay_amount=decay_amount)
