Part 12: Increasing Difficulty

Author: jmccardle

game/components/consumable.py

@@ -16,7 +16,9 @@
 class Consumable(game.components.base_component.BaseComponent):
     parent: game.entity.Item
 
-    def get_action(self, consumer: game.entity.Actor) -> Optional[Union[game.actions.Action, game.input_handlers.BaseEventHandler]]:
+    def get_action(
+        self, consumer: game.entity.Actor
+    ) -> Optional[Union[game.actions.Action, game.input_handlers.BaseEventHandler]]:
         """Try to return the action for this item."""
         return game.actions.ItemAction(consumer, self.parent)
 

game/game_map.py

@@ -111,8 +111,6 @@ def __init__(
         max_rooms: int,
         room_min_size: int,
         room_max_size: int,
-        max_monsters_per_room: int,
-        max_items_per_room: int,
         current_floor: int = 0,
     ):
         self.engine = engine
@@ -125,9 +123,6 @@ def __init__(
         self.room_min_size = room_min_size
         self.room_max_size = room_max_size
 
-        self.max_monsters_per_room = max_monsters_per_room
-        self.max_items_per_room = max_items_per_room
-
         self.current_floor = current_floor
 
     def generate_floor(self) -> None:
@@ -141,7 +136,6 @@ def generate_floor(self) -> None:
             room_max_size=self.room_max_size,
             map_width=self.map_width,
             map_height=self.map_height,
-            max_monsters_per_room=self.max_monsters_per_room,
-            max_items_per_room=self.max_items_per_room,
+            current_floor=self.current_floor,
             engine=self.engine,
         )

game/procgen.py

@@ -2,7 +2,7 @@
 
 import copy
 import random
-from typing import Iterator, List, Tuple, TYPE_CHECKING
+from typing import Dict, Iterator, List, Tuple, TYPE_CHECKING
 
 import tcod
 
@@ -15,6 +15,69 @@
     import game.game_map
 
 
+max_items_by_floor = [
+    (1, 1),
+    (4, 2),
+]
+
+max_monsters_by_floor = [
+    (1, 2),
+    (4, 3),
+    (6, 5),
+]
+
+item_chances: Dict[int, List[Tuple[game.entity.Entity, int]]] = {
+    0: [(game.entity_factories.health_potion, 35)],
+    2: [(game.entity_factories.confusion_scroll, 10)],
+    4: [(game.entity_factories.lightning_scroll, 25)],
+    6: [(game.entity_factories.fireball_scroll, 25)],
+}
+
+enemy_chances: Dict[int, List[Tuple[game.entity.Entity, int]]] = {
+    0: [(game.entity_factories.orc, 80)],
+    3: [(game.entity_factories.troll, 15)],
+    5: [(game.entity_factories.troll, 30)],
+    7: [(game.entity_factories.troll, 60)],
+}
+
+
+def get_max_value_for_floor(weighted_chances_by_floor: List[Tuple[int, int]], floor: int) -> int:
+    current_value = 0
+
+    for floor_minimum, value in weighted_chances_by_floor:
+        if floor_minimum > floor:
+            break
+        else:
+            current_value = value
+
+    return current_value
+
+
+def get_entities_at_random(
+    weighted_chances_by_floor: Dict[int, List[Tuple[game.entity.Entity, int]]],
+    number_of_entities: int,
+    floor: int,
+) -> List[game.entity.Entity]:
+    entity_weighted_chances = {}
+
+    for key, values in weighted_chances_by_floor.items():
+        if key > floor:
+            break
+        else:
+            for value in values:
+                entity = value[0]
+                weighted_chance = value[1]
+
+                entity_weighted_chances[entity] = weighted_chance
+
+    entities = list(entity_weighted_chances.keys())
+    entity_weighted_chance_values = list(entity_weighted_chances.values())
+
+    chosen_entities = random.choices(entities, weights=entity_weighted_chance_values, k=number_of_entities)
+
+    return chosen_entities
+
+
 class RectangularRoom:
     def __init__(self, x: int, y: int, width: int, height: int):
         self.x1 = x
@@ -60,41 +123,21 @@ def tunnel_between(start: Tuple[int, int], end: Tuple[int, int]) -> Iterator[Tup
 def place_entities(
     room: RectangularRoom,
     dungeon: game.game_map.GameMap,
-    maximum_monsters: int,
-    maximum_items: int,
+    floor_number: int,
 ) -> None:
-    number_of_monsters = random.randint(0, maximum_monsters)
-    number_of_items = random.randint(0, maximum_items)
+    number_of_monsters = random.randint(0, get_max_value_for_floor(max_monsters_by_floor, floor_number))
+    number_of_items = random.randint(0, get_max_value_for_floor(max_items_by_floor, floor_number))
 
-    for _ in range(number_of_monsters):
-        x = random.randint(room.x1 + 1, room.x2 - 1)
-        y = random.randint(room.y1 + 1, room.y2 - 1)
+    monsters: List[game.entity.Entity] = get_entities_at_random(enemy_chances, number_of_monsters, floor_number)
+    items: List[game.entity.Entity] = get_entities_at_random(item_chances, number_of_items, floor_number)
 
-        if not any(entity.x == x and entity.y == y for entity in dungeon.entities):
-            if random.random() < 0.8:
-                monster = copy.deepcopy(game.entity_factories.orc)
-            else:
-                monster = copy.deepcopy(game.entity_factories.troll)
-
-            monster.place(x, y, dungeon)
-
-    for _ in range(number_of_items):
+    for entity in monsters + items:
         x = random.randint(room.x1 + 1, room.x2 - 1)
         y = random.randint(room.y1 + 1, room.y2 - 1)
 
         if not any(entity.x == x and entity.y == y for entity in dungeon.entities):
-            item_chance = random.random()
-
-            if item_chance < 0.7:
-                item = copy.deepcopy(game.entity_factories.health_potion)
-            elif item_chance < 0.8:
-                item = copy.deepcopy(game.entity_factories.fireball_scroll)
-            elif item_chance < 0.9:
-                item = copy.deepcopy(game.entity_factories.confusion_scroll)
-            else:
-                item = copy.deepcopy(game.entity_factories.lightning_scroll)
-
-            item.place(x, y, dungeon)
+            entity_copy = copy.deepcopy(entity)
+            entity_copy.place(x, y, dungeon)
 
 
 def generate_dungeon(
@@ -103,8 +146,7 @@ def generate_dungeon(
     room_max_size: int,
     map_width: int,
     map_height: int,
-    max_monsters_per_room: int,
-    max_items_per_room: int,
+    current_floor: int,
     engine: game.engine.Engine,
 ) -> game.game_map.GameMap:
     """Generate a new dungeon map."""
@@ -139,7 +181,7 @@ def generate_dungeon(
             for x, y in tunnel_between(rooms[-1].center, new_room.center):
                 dungeon.tiles[x, y] = game.tiles.floor
 
-        place_entities(new_room, dungeon, max_monsters_per_room, max_items_per_room)
+        place_entities(new_room, dungeon, current_floor)
 
         # Finally, append the new room to the list.
         rooms.append(new_room)

game/setup_game.py

@@ -38,9 +38,6 @@ def new_game() -> game.engine.Engine:
     room_min_size = 6
     max_rooms = 30
 
-    max_monsters_per_room = 2
-    max_items_per_room = 2
-
     player = copy.deepcopy(game.entity_factories.player)
 
     engine = game.engine.Engine(player=player)
@@ -52,8 +49,6 @@ def new_game() -> game.engine.Engine:
         room_max_size=room_max_size,
         map_width=map_width,
         map_height=map_height,
-        max_monsters_per_room=max_monsters_per_room,
-        max_items_per_room=max_items_per_room,
     )
     engine.game_world.generate_floor()
     engine.update_fov()