def place_entities(x, y, size, entities, items, game_map,
max_monsters_per_room, max_items_per_room):
number_of_monsters = randint(10, max_monsters_per_room)
number_of_items = randint(10, max_items_per_room)
# print("Monsters ", number_of_monsters)
# print("Items ", number_of_items)
monster_chances = {'ghost': 80, 'angry_ghost': 20}
item_chances = {
'heal potion': 70,
'lightning scroll': 10,
'fireball scroll': 10,
'confuse scroll': 10
}
print("coords ", x, y)
for i in range(number_of_monsters):
mx = randint(x, x + size)
my = randint(y, y + size)
print("monsters coord ", mx, my)
if (not (mx, my) in entities) and (not (mx, my) in game_map.terrain):
monster_choice = random_choice_from_dict(monster_chances)
if monster_choice == 'ghost':
fighter_component = Fighter(hp=1, defense=0, power=1)
ai_component = BasicMonster()
monster = Entity(mx,
my,
'[U+7030]',
'gray',
'Ghost',
fighter=fighter_component,
ai=ai_component)
else:
fighter_component = Fighter(hp=1, defense=1, power=1)
ai_component = BasicMonster()
monster = Entity(mx,
my,
'[U+7010]',
'white',
'Troll',
fighter=fighter_component,
ai=ai_component)
entities[(monster.x, monster.y)] = monster
for i in range(number_of_items):
print('Items start pont', x, y)
ix = randint(x, x + size)
iy = randint(y, y + size)
print("items coord", ix, iy)
if not ((ix, iy) in game_map.terrain) and not ((ix, iy) in items):
item_choice = random_choice_from_dict(item_chances)
if item_choice == 'heal potion':
item = Entity(ix, iy, '[U+3000]', 'red', item_choice)
elif item_choice == 'lightning scroll':
item = Entity(ix, iy, '[U+6000]', 'yellow', item_choice)
elif item_choice == 'fireball scroll':
item = Entity(ix, iy, '[U+6000]', 'red', item_choice)
elif item_choice == 'confuse scroll':
item = Entity(ix, iy, '[U+6000]', 'pink', item_choice)
items[(item.x, item.y)] = item
def __init__(self, average_tree_diameter):
self.average_tree_diameter = average_tree_diameter
self.primary = random_choice_from_dict(tree_choices)
self.secondary = random_choice_from_dict(tree_choices)
self.tree_choices = {}
self.tree_choices[self.primary] = 90
self.tree_choices[self.secondary] = 10
def place_entities(self, room, entities):
"""Place a random number of monsters in each room of the map."""
max_monsters_per_room = from_dungeon_level(max_monsters_dungeon, self.dungeon_level)
max_items_per_room = from_dungeon_level(max_items_dungeon, self.dungeon_level)
# Get a random number of monsters and items
number_of_monsters = rd.randint(0, max_monsters_per_room)
number_of_items = rd.randint(0, max_items_per_room)
# Generate dictionary (elem -> chance ) for the appropriate dungeon level
monster_chances = {m['id']: from_dungeon_level(m['spawn_chance'], self.dungeon_level) for m in monsters}
consumables_chances = {c['id']: from_dungeon_level(c['drop_chance'], self.dungeon_level) for c in consumables}
equipment_chances = {e['id']: from_dungeon_level(e['drop_chance'], self.dungeon_level) for e in equipment}
# === Monsters ===
for i in range(number_of_monsters):
# Choose a random location in the room
x = rd.randint(room.x1 + 1, room.x2 - 1)
y = rd.randint(room.y1 + 1, room.y2 - 1)
tile_occupied = any([entity for entity in entities if entity.x == x and entity.y == y])
if not tile_occupied and self.tiles[x][y].can_spawn:
monster_choice = random_choice_from_dict(monster_chances)
for monster in monsters:
if monster_choice == monster['id']:
monster_entity = self.create_monster_entity(x, y, monster, monster['equipment'])
entities.append(monster_entity)
# === Items ===
for i in range(number_of_items):
x = rd.randint(room.x1 + 1, room.x2 - 1)
y = rd.randint(room.y1 + 1, room.y2 - 1)
tile_occupied = any([entity for entity in entities if entity.x == x and entity.y == y])
if not tile_occupied and self.tiles[x][y].can_spawn:
select_item_pool = rd.randint(0, 100)
if select_item_pool < 70:
item_choice = random_choice_from_dict(consumables_chances)
for consumable in consumables:
if item_choice == consumable['id']:
item = self.create_item_entity(x, y, consumable)
else:
item_choice = random_choice_from_dict(equipment_chances)
for equippable in equipment:
if item_choice == equippable['id']:
item = self.create_item_entity(x, y, equippable, is_equippable=True)
entities.append(item)
def generate_location(self):
location_choice = random_choice_from_dict(weight_factor(self.locations))
location = self.locations[location_choice]
location_type = random_choice_from_dict(location['types'])
if location_choice == 'temple':
name = '{0} of the {1}'.format(location_type, choice(location['names']))
elif location_choice == 'settlement':
name = '{0} {1} {2}'.format(choice(location['first_names']), choice(location['last_names']), location_type).strip()
landmark = self.generate_landmark(name, location_choice, location_type)
location = GameMap(map_vars.width, map_vars.height, map_creator=ForestMap(5, landmark=landmark))
return location
def place_entities(self, room, entities):
max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]],
self.dungeon_level)
max_items_per_room = from_dungeon_level([[1, 1], [2, 4]],
self.dungeon_level)
# Get a random number of monsters
number_of_monsters = randint(0, max_monsters_per_room)
number_of_items = randint(0, max_items_per_room)
monster_chances, item_chances = get_content(self)
for i in range(number_of_monsters):
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
#choose a random location in room
if self.tiles[x][y].blocked == True:
skip = True
else:
skip = False
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]) and not skip:
monster_choice = random_choice_from_dict(monster_chances)
monster = create_entity(x, y, monster_choice)
entities.append(monster)
for i in range(number_of_items):
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
#choose a random location in room
if self.tiles[x][y].blocked == True:
skip = True
else:
skip = False
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]) and not skip:
item_choice = random_choice_from_dict(item_chances)
item = create_item(x, y, item_choice)
entities.append(item)
def initialize_tiles(self):
forest_chars = {
str(chr(tcod.CHAR_ARROW_N)): 25,
str(chr(tcod.CHAR_VLINE)): 5,
str(chr(tcod.CHAR_ARROW2_S)): 10,
'|': 3,
'\\': 7,
'/': 7,
'T': 40,
'Y': 35,
}
tiles = [[None for y in range(self.height)] for x in range(self.width)]
for x in range(self.width):
for y in range(self.height):
tile = WorldTile(biom=Biomes.FOREST,
bg_color=color_vars.forest_bg)
tree_entity = Entity(
x,
y,
char=random_choice_from_dict(forest_chars),
color=color_vars.forest)
tile.place_static_entity(tree_entity)
tiles[x][y] = tile
return tiles
def grow_thicket(self, center_x, center_y, map_obj, flora_data=fungi):
flora_choices = weight_factor(flora_data)
flora_choice = random_choice_from_dict(flora_choices)
plant_info = flora_data[flora_choice]
self.thickets.append({
'center': (center_x, center_y),
'plant': flora_choice,
})
min_radius = flora_data.get('min_thicket_radius', 0)
max_radius = flora_data.get('max_thicket_radius', 5)
thicket_radius = randint(min_radius, max_radius)
for distance in range(thicket_radius):
chance_for_plant = distance * 20
for dx in range(-distance, distance):
dy = int(pow(distance * distance - dx * dx, 0.5))
dys = [-dy, dy]
for dy in dys:
if randint(0, 100) < chance_for_plant:
continue
x = center_x + dx
y = center_y + dy
if not map_obj.is_void(
x, y) and not map_obj.tiles[x][y].static_entities:
map_obj.tiles[x][y].place_static_entity(
self.plant(x, y, plant_info))
def return_scrolls(self, x, y):
item_chances = {
'a': 10,
'b': from_dungeon_level([[2, 4]], self.dungeon_level),
'c': from_dungeon_level([[3, 4]], self.dungeon_level),
'd': from_dungeon_level([[4, 4]], self.dungeon_level),
'e': from_dungeon_level([[5, 4]], self.dungeon_level),
'f': from_dungeon_level([[6, 4]], self.dungeon_level),
'g': from_dungeon_level([[7, 4]], self.dungeon_level),
'h': 10,
'i': from_dungeon_level([[2, 4]], self.dungeon_level),
'j': from_dungeon_level([[3, 4]], self.dungeon_level),
'k': from_dungeon_level([[4, 4]], self.dungeon_level),
'l': from_dungeon_level([[5, 4]], self.dungeon_level),
'm': from_dungeon_level([[6, 4]], self.dungeon_level)
}
item_choice = random_choice_from_dict(item_chances)
if item_choice == 'a':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=12, radius=2)
item = Entity(x, y, '#', libtcod.red, 'Smudged Burnt Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'b':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=15, radius=2)
item = Entity(x, y, '#', libtcod.red, 'Burnt Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'c':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=17, radius=3)
item = Entity(x, y, '#', libtcod.red, 'Smudged Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'd':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=25, radius=3)
item = Entity(x, y, '#', libtcod.red, 'Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'e':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=35, radius=3)
item = Entity(x, y, '#', libtcod.red, 'Calculated Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'f':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message( 'Left-click a target tile for the fireball, or right-click to cancel.', libtcod.light_cyan), damage=50, radius=5)
item = Entity(x, y, '#', libtcod.red, 'Bloodfeud Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'g':
item_component = Item(use_function=cast_confuse, targeting=True, targeting_message=Message('Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan))
item = Entity(x, y, '#', libtcod.light_pink, 'Confusion Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'h':
item_component = Item(use_function=cast_lightning, damage=15, maximum_range=4)
item = Entity(x, y, '#', libtcod.yellow, 'Smudged Burnt Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'i':
item_component = Item(use_function=cast_lightning, damage=20, maximum_range=4)
item = Entity(x, y, '#', libtcod.yellow, 'Burnt Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'j':
item_component = Item(use_function=cast_lightning, damage=25, maximum_range=5)
item = Entity(x, y, '#', libtcod.yellow, 'Smudged Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'k':
item_component = Item(use_function=cast_lightning, damage=40, maximum_range=5)
item = Entity(x, y, '#', libtcod.yellow, 'Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'l':
item_component = Item(use_function=cast_lightning, damage=60, maximum_range=5)
item = Entity(x, y, '#', libtcod.yellow, 'Calculated Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'm':
item_component = Item(use_function=cast_lightning, damage=80, maximum_range=7)
item = Entity(x, y, '#', libtcod.yellow, 'Bloodfeud Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
return item
def place_specific_entity(x, y, entities, otype, dungeon_level=1):
item = load_rand_entity(random_choice_from_dict(otype),
otype,
x,
y,
dungeon_level=1)
return (item)
def make_beds(self):
plant_choices = {
'turnip': 25,
'potato': 30,
'tomato': 25,
'beetroot': 25,
}
number_of_beds = self.rect.h if self.rect.h < self.rect.w else self.rect.w
self.beds = [random_choice_from_dict(plant_choices) for _ in range(number_of_beds)]
def grow_cave_entrance_zone(self, cave, zones):
wall_plant_choices = weight_factor(entrance_plants['wall'])
ground_plant_choices = weight_factor(entrance_plants['ground'])
for entrance_zone in zones:
center_x, center_y = entrance_zone['center']
for x, y in entrance_zone['coords']:
if cave.tiles[x][y].static_entities:
continue
distance_from_center = math.sqrt(
pow(center_x - x, 2) + pow(center_y - y, 2))
chance_for_growth = distance_from_center * 2
if randint(0, 100) < chance_for_growth:
continue
if cave.is_blocked(x, y):
plant_info = entrance_plants['wall'][
random_choice_from_dict(wall_plant_choices)]
else:
plant_info = entrance_plants['ground'][
random_choice_from_dict(ground_plant_choices)]
char = plant_info['char']
base_name = plant_info['name']
name = plant_info['display_name']
color = plant_info['color']
if type(color) == list:
color = choice(color)
if plant_info.get('bloom_factor'):
if randint(1, 100) <= plant_info['bloom_factor']:
color = plant_info['flower_color']
name = 'Blooming {0}'.format(name)
plant = Entity(x,
y,
char=char,
color=color,
name=name,
base_name=base_name,
render_order=RenderOrder.GROUND_FLORA)
cave.tiles[x][y].place_static_entity(plant)
def choose_plant(self, tile_shadowed):
plant_choices = one_tile_plant_choices.copy()
if tile_shadowed:
plant_choices.update(weight_factor(fungi))
plant_choices.update({k: (v // 3) for k, v in saplings.items()})
plant_choices.update({k: (v * 2) for k, v in soil.items()})
else:
plant_choices.update(saplings)
plant_choices.update(soil)
return random_choice_from_dict(plant_choices)
def populate_by_type(self, points, monster_type, entities):
monster_list = {}
for name, monster in self.monsters.items():
if monster_type in monster['types']:
monster_list[name] = monster
monster_chances = weight_factor(monster_list)
for x, y in points:
monster_choice = random_choice_from_dict(monster_chances)
monster = self.get_monster(x, y, monster_choice)
entities.append(monster)
def populate_room(self, room, dungeon_level, entities):
max_monsters_per_room = from_dungeon_level(max_monsters_per_room_weights, dungeon_level)
number_of_monsters = randint(0, max_monsters_per_room)
monster_chances = weight_factor(monsters, dungeon_level)
for _ in range(number_of_monsters):
# Choose a random location in room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not entities.find_by_point(x, y):
monster_choice = random_choice_from_dict(monster_chances)
monster = self.get_monster(x, y, monster_choice)
entities.append(monster)
def generate_location(self):
location_choice = random_choice_from_dict(weight_factor(
self.locations))
location = self.locations[location_choice]
location_type = random_choice_from_dict(location['types'])
if location_choice == 'city':
name = 'Remains of {0} of the city of {1}'.format(
location_type, choice(location['names']))
elif location_choice == 'cave':
name = '{0} of {1}'.format(location_type,
choice(location['names'])).strip()
landmark = Landmark(name, location_choice, location_type)
return GameMap(map_vars.width,
map_vars.height,
map_creator=CaveMap(landmark=landmark))
landmark = Landmark(name, location_choice, location_type)
location = GameMap(map_vars.width,
map_vars.height,
map_creator=DungeonMap(10, 3, 5, landmark=landmark))
return location
def place_mozaic_objects(self, obj_list, game_map, obj_char, place_chance, blocked = False, block_sight = False):
place_choices = {
'place': place_chance,
'dont': 100 - place_chance,
}
for (x, y) in obj_list:
if random_choice_from_dict(place_choices) == 'place':
game_map.tiles[x][y].place_static_entity(Entity(x, y, **obj_char))
if blocked:
game_map.tiles[x][y].regulatory_flags.add('blocked')
if block_sight:
game_map.tiles[x][y].regulatory_flags.add('block_sight')
def fill_room(self, room, dungeon_level, entities):
max_items_per_room = from_dungeon_level(max_items_per_room_weights, dungeon_level)
number_of_items = randint(0, max_items_per_room)
item_chances = weight_factor(items, dungeon_level)
for _ in range(number_of_items):
# Choose a random location in room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not entities.find_by_point(x, y):
item_choice = random_choice_from_dict(item_chances)
item = self.get_item(x, y, item_choice)
entities.append(item)
def populate(self, forest, entities):
number_of_monsters = round(math.pow(forest.width * forest.height,
0.25))
monster_chances = weight_factor(monsters)
for _ in range(number_of_monsters):
# Choose a random location in room
x = randint(0, forest.width - 1)
y = randint(0, forest.height - 1)
if not forest.is_blocked(x, y) and not entities.find_by_point(
x, y):
monster_choice = random_choice_from_dict(monster_chances)
monster = self.get_monster(x, y, monster_choice)
entities.append(monster)
def place_entities(self, room, entities): max_monsters_per_room = from_dungeon_level([[3,1],[5,3],[8,5]], self.dungeon_level) max_items_per_room = from_dungeon_level([[1,1],[2,4]], self.dungeon_level) # Get a random number of monsters number_of_monsters = randint(0, max_monsters_per_room) # Get a random number of items number_of_items = randint(0, max_items_per_room) monster_chances = get_easy_monsters(self.dungeon_level) item_chances = get_early_items(self.dungeon_level) for i in range(number_of_monsters): # Choose a random location in the room x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) # Check if an entity is already in that location if not any([entity for entity in entities if entity.x == x and entity.y == y]): monster_choice = random_choice_from_dict(monster_chances) monster = choose_easy_monster(monster_choice, self.dungeon_level, x, y) entities.append(monster) for i in range(number_of_items): x = randint(room.x1 + 1, room.x2 - 1) y = randint(room.y1 + 1, room.y2 - 1) if not any([entity for entity in entities if entity.x == x and entity.y == y]): item_choice = random_choice_from_dict(item_chances) item = choose_early_item(item_choice, x, y) entities.append(item)
def generate_enchantment(self, dungeon_level):
"Generates a random enchantment for the given item based on dungeon level. The modifier will potentially apply a bonus and change the name of the item"
modifierChances = {
key: from_dungeon_level(value.chance, dungeon_level)
for key, value in equippable_enchantment.items()
if self.slot in value.slot_restrictions
}
modifier_name = random_choice_from_dict(modifierChances)
modifier = equippable_enchantment.get(modifier_name)
if modifier.bonus_dic:
for key, value in modifier.bonus_dic.items():
# Bonus type is whatever is written in modifier
setattr(self, key, getattr(self, key) + value)
return ' of ' + modifier_name
return ''
def handle_blood_path(self):
blood_char = random_choice_from_dict(self.blood_chars)
blood_entity = Entity(self.body_part.x,
self.body_part.y,
char=blood_char,
color=color_vars.blood,
name='Drop of blood',
render_order=RenderOrder.EFFECT)
self.engine.world_map.current_dungeon.tiles[self.body_part.x][
self.body_part.y].place_static_entity(blood_entity)
self.animation_entities.append(blood_entity)
if len(self.animation_entities) > self.trail_length:
entity_to_remove = self.animation_entities.pop(0)
tile = self.engine.world_map.current_dungeon.tiles[
entity_to_remove.x][entity_to_remove.y]
tile.remove_static_entity(entity_to_remove)
def choose_encounter(self):
possible_encounters = self.possible_encounters()
if not possible_encounters:
return False
challenge = choice(list(EncounterChallenge))
encounter_choices = weight_factor(possible_encounters)
encounter_choice = random_choice_from_dict(encounter_choices)
encounter_conf = possible_encounters[encounter_choice]
self.encounter = encounter_conf['class'](
encounter_choice,
challenge=challenge,
**encounter_conf['parameters'])
return True
def populate_cave(self, cave, entities):
max_monsters = from_dungeon_level(max_monsters_per_level_weights, cave.dungeon_level)
number_of_monsters = randint(0, max_monsters)
monster_chances = weight_factor(monsters, cave.dungeon_level)
if cave.map_creator.twilight_zone:
zone = cave.map_creator.twilight_zone
elif cave.map_creator.dark_zone:
zone = cave.map_creator.dark_zone
for _ in range(number_of_monsters):
x, y = choice(tuple(zone))
if not entities.find_by_point(x, y):
monster_choice = random_choice_from_dict(monster_chances)
monster = self.get_monster(x, y, monster_choice)
entities.append(monster)
def get_tree(self):
diameter = randint(1, self.average_tree_diameter * 2)
tree_key = random_choice_from_dict(self.tree_choices)
base_name = base_name = trees[tree_key]['name']
if diameter < 4:
name = 'Trunk of {0}'.format(base_name)
else:
name = 'Giant trunk of {0}'.format(base_name)
return Entity(-1,
-1,
bg_color=trees[tree_key]['color'],
name=name,
base_name=base_name,
blocks=True,
tree=Tree(diameter=diameter))
def make_landmark_objects(self):
# family house
main_hold = random_choice_from_dict({
'house': 70,
'hut': 30,
})
if main_hold == 'house':
main_hold_method = self.make_house
else:
main_hold_method = self.make_hut
self.make_landmark_object('main_hold', main_hold_method)
# sheds
self.make_landmark_object('shed', self.make_shed)
# kitchen-garden
self.make_landmark_object('kitchen-garden', self.make_kitchen_garden)
def next_tick(self):
if self.path_index >= len(self.path) or self.completed:
return []
x, y = self.path[self.path_index]
lightning_arc = Entity(x,
y,
char=random_choice_from_dict(
self.lightning_chars),
color=color_vars.lightning_arc,
name='Lightning Arc',
render_order=RenderOrder.EFFECT)
self.lightning_entities.append(lightning_arc)
self.engine.entities.append(lightning_arc)
self.path_index += 1
if self.path_index >= len(self.path):
return self.complete()
return []
def generate_material(self, dungeon_level):
"Generates a random material for the given item based on dungeon level. The modifier will potentially apply a bonus and change the name of the item. Bonus will usually be defensive for armor and offensive for weapons"
modifierChances = {
key: from_dungeon_level(value.chance, dungeon_level)
for key, value in equippable_material.items()
if self.slot in value.slot_restrictions
}
modifier_name = random_choice_from_dict(modifierChances)
modifier = equippable_material.get(modifier_name)
if modifier.bonus_dic:
for _, value in modifier.bonus_dic.items():
# Set power if weapon, defense if armor
if self.slot in EquipmentSlotGroups.WEAPONS:
setattr(self, 'power_bonus',
getattr(self, 'power_bonus') + value)
else:
setattr(self, 'defense_bonus',
getattr(self, 'defense_bonus') + value)
return modifier_name + ' '
return ''
def place_monsters(m, chunks, monster_chances, level):
entities = []
chance_any = monster_chances["any"]
del monster_chances["any"]
max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], level + 1)
for idx, c in enumerate(chunks):
c.monsters = []
rval = random.randint(0, 100)
if rval > chance_any:
continue
if idx == 0:
num_monsters = 1 # don't overwhelm in the first room
else:
num_monsters = random.randint(1, max_monsters_per_room)
room_center = Pos(c.x + c.width // 2, c.y + c.height // 2)
skip_room = False
for _ in range(num_monsters):
x = random.randint(c.x + 1, c.x + c.width - 1)
y = random.randint(c.y + 1, c.y + c.height - 1)
if idx == 0:
# first room, don't spawn right next to player
attempts = 0
while Pos(x, y).distance_to(room_center) < 4:
x = random.randint(c.x + 1, c.x + c.width - 2)
y = random.randint(c.y + 1, c.y + c.height - 2)
attempts += 1
if attempts > 100:
skip_room = True
if skip_room:
continue
already_there = [entity for entity in entities if entity.pos.x == x and entity.pos.y == y]
if not any(already_there) and not m.tiles[x][y].blocked:
monster_choice = random_choice_from_dict(monster_chances)
monster_data = get_monster(x, y, m, c, monster_choice, entities)
entities.extend(monster_data)
c.monsters.extend(monster_data)
m.entities = entities
def place_entities(self, room, player):
entities = []
# Get a random number of monsters
max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level)
number_of_monsters = randint(0, max_monsters_per_room)
monster_chances = {
'kobold': from_dungeon_level([[80, 1], [40, 3], [20, 4], [0, 5]], self.dungeon_level),
'orc': from_dungeon_level([[40, 1], [80, 2]], self.dungeon_level),
'troll': from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level),
'ogre': from_dungeon_level([[20, 2], [15, 4], [0, 6]], self.dungeon_level),
'red_dragon': from_dungeon_level([[5, 5], [10, 6], [15, 7]], self.dungeon_level),
}
for i in range(number_of_monsters):
# Choose a random location in the room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not any([entity for entity in entities if entity.x == x and entity.y == y]) and \
player.x != x and player.y != y:
monster_choice = random_choice_from_dict(monster_chances)
if monster_choice == 'red_dragon' and self.number_of_bosses < self.max_number_of_bosses:
monster = spawn_dragon(x, y)
self.number_of_bosses += 1
elif monster_choice == 'ogre' and self.number_of_bosses < self.max_number_of_bosses:
monster = spawn_ogre(x, y)
self.number_of_bosses += 1
elif monster_choice == 'troll':
monster = spawn_troll(x, y)
elif monster_choice == 'orc':
monster = spawn_orc(x, y)
else:
monster = spawn_kobold(x, y)
entities.append(monster)
return entities
def __init__(self, max_rooms, room_min_size, room_max_size, landmark=None):
super().__init__()
self.default_tile_blocked = True
self.max_rooms = max_rooms
self.room_min_size = room_min_size
self.room_max_size = room_max_size
self.landmark = landmark
self.player_start = None
self.flora = Flora()
self.fauna = Fauna()
self.loot = Loot()
materials = {
'stone': color_vars.dungeon_stone,
'dirt': color_vars.dungeon_dirt,
}
self.material = materials[random_choice_from_dict({
'stone': 10,
'dirt': 10,
})]
def place_entities(self, room, entities):
max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]], self.dungeon_level)
max_items_per_room = from_dungeon_level([[1, 1], [2, 4]], self.dungeon_level)
#get a random number of monsters
number_of_monsters = randint(0, max_monsters_per_room)
number_of_items = randint(0, max_items_per_room)
monster_chances = {
'orc': 80,
'troll':from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level)
}
item_chances = {
'healing_potion': 35,
'lightning_scroll': from_dungeon_level([[25, 4]], self.dungeon_level),
'fireball_scroll': from_dungeon_level([[25, 6]], self.dungeon_level),
'confusion_scroll': from_dungeon_level([[10, 2]], self.dungeon_level)
}
for i in range(number_of_monsters):
#choose a random location in the room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not any([entity for entity in entities if entity.x == x and entity.y == y]):
monster_choice = random_choice_from_dict(monster_chances)
if monster_choice == 'orc':
fighter_component = Fighter(hp=20, defense=0, power=4, xp=35)
ai_component = BasicMonster()
monster = Entity(x, y, 'o', libtcod.desaturated_green, 'Orc', blocks=True, render_order=RenderOrder.ACTOR,
fighter=fighter_component, ai=ai_component)
else:
fighter_component = Fighter(hp=30, defense=2, power=8, xp=100)
ai_component = BasicMonster()
monster = Entity(x, y, 'T', libtcod.darker_green, 'Troll', blocks=True,
fighter=fighter_component, render_order=RenderOrder.ACTOR, ai=ai_component)
entities.append(monster)
for i in range(number_of_items):
x = randint(room.x1 + 1, room.x2 - 1)
y = randint (room.y1 + 1, room.y2 - 1)
if not any([entity for entity in entities if entity.x == x and entity.y == y]):
item_choice = random_choice_from_dict(item_chances)
if item_choice == 'healing_potion':
item_component = Item(use_function=heal, amount=40)
item = Entity(x, y, '!', libtcod.violet, 'Healing Potion', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'fireball_scroll':
item_component = Item(use_function=cast_fireball, targeting=True, targeting_message=Message('Left-click a target tile for the fireball, or right click to canc el.', libtcod.light_cyan), damage=25, radius=3)
item = Entity(x, y, '#', libtcod.red, 'Fireball Scroll', render_order=RenderOrder.ITEM, item=item_component)
elif item_choice == 'confuction_scroll':
item_component = Item(use_function=cast_confuse, targeting=True, targeting_message=Message('Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan))
item = Entity(x, y, '#', libtcod.light_pink, 'Confusion Scroll', render_order=RenderOrder.ITEM, item=item_component)
else:
item_component = Item(use_function=cast_lightning, damage=40, maximum_range=5)
item = Entity(x, y, '#', libtcod.yellow, 'Lightning Scroll', render_order=RenderOrder.ITEM, item=item_component)
entities.append(item)
