I can probably do it myself from here, IDK

README.md

@@ -8,5 +8,5 @@ The "water meter" is always visible, and ticks down each time you take an action
 
 I'm working from this:
 
-https://rogueliketutorials.com/tutorials/tcod/v2/part-2/
+https://rogueliketutorials.com/tutorials/tcod/v2/part-4/
 

source/actions.py

@@ -1,14 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+	from engine import Engine
+	from entity import Entity
+
 class Action: #lawsuit?
-    pass
+	def perform(self, engine: Engine, entity: Entity) -> None:
+		"Oh look, the visitor pattern!"
+		raise NotImplementedError()
 
 
 class EscapeAction(Action):
-    pass
+	def perform(self, engine: Engine, entity: Entity) -> None:
+		raise SystemExit()
 
 
 class MovementAction(Action):
-    def __init__(self, dx: int, dy: int):
-        super().__init__()
+	def __init__(self, dx: int, dy: int):
+		super().__init__()
+
+		self.dx = dx
+		self.dy = dy
+
+	def perform(self, engine: Engine, entity: Entity) -> None:
+		dest_x = entity.x + self.dx
+		dest_y = entity.y + self.dy
+
+		if not engine.game_map.in_bounds(dest_x, dest_y):
+			return
+		if not engine.game_map.tiles["walkable"][dest_x, dest_y]:
+			return
+		
+		entity.set_pos(dest_x, dest_y)
 
-        self.dx = dx
-        self.dy = dy

source/engine.py

@@ -3,15 +3,17 @@ from typing import Set, Iterable, Any
 from tcod.context import Context
 from tcod.console import Console
 
+from event_handler import EventHandler
 from actions import EscapeAction, MovementAction
-from input_events import EventHandler
 
 from entity import Entity
+from game_map import GameMap
 
 class Engine:
-	def __init__(self, entities: Set[Entity], event_handler: EventHandler, player: Entity):
+	def __init__(self, entities: Set[Entity], event_handler: EventHandler, game_map: GameMap, player: Entity):
 		self.entities = entities
 		self.event_handler = event_handler
+		self.game_map = game_map
 		self.player = player
 	
 	def handle_events(self, events: Iterable[Any]) -> None:
@@ -21,13 +23,11 @@ class Engine:
 			if action is None:
 				continue
 			
-			elif isinstance(action, EscapeAction):
-				raise SystemExit()
-			
-			elif isinstance(action, MovementAction):
-				self.player.move(action.dx, action.dy)
+			action.perform(self, self.player)
 	
 	def render(self, console: Console, context: Context) -> None:
+		self.game_map.render(console)
+
 		for entity in self.entities:
 			console.print(entity.x, entity.y, entity.char, fg=entity.color)
 		

source/entity.py

@@ -2,16 +2,13 @@ from typing import Tuple
 
 
 class Entity:
-    """
-    A generic object to represent players, enemies, items, etc.
-    """
     def __init__(self, x: int, y: int, char: str, color: Tuple[int, int, int]):
         self.x = x
         self.y = y
         self.char = char
         self.color = color
 
-    def move(self, dx: int, dy: int) -> None:
+    def set_pos(self, dx: int, dy: int) -> None:
         # Move the entity by a given amount
-        self.x += dx
-        self.y += dy
+        self.x = dx
+        self.y = dy

source/game_map.py

@@ -0,0 +1,18 @@
+import numpy as np
+from tcod.console import Console
+
+import tile_types
+
+
+class GameMap:
+	def __init__(self, width: int, height: int):
+		self.width = width
+		self.height = height
+		self.tiles = np.full((width, height), fill_value=tile_types.wall, order="F")
+
+	def in_bounds(self, x: int, y: int) -> bool:
+		"""Return True if x and y are inside of the bounds of this map."""
+		return 0 <= x < self.width and 0 <= y < self.height
+	
+	def render(self, console: Console) -> None:
+		console.rgb[0:self.width, 0:self.height] = self.tiles["dark"]

source/main.py

@@ -3,7 +3,8 @@ import tcod
 
 from engine import Engine
 from entity import Entity
-from input_events import EventHandler
+from procgen import generate_dungeon
+from event_handler import EventHandler
 
 
 def main() -> None:
@@ -11,16 +12,25 @@ def main() -> None:
 	screen_width = 80
 	screen_height = 50
 
-	tileset = tcod.tileset.load_tilesheet("assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD)
+	map_width = 80
+	map_height = 45
 
-	event_handler = EventHandler()
+	room_size_max = 10
+	room_size_min = 6
+	room_count_max = 30
+
+	tileset = tcod.tileset.load_tilesheet("assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD)
 
 	#entities
 	player = Entity(screen_width // 2, screen_height // 2, "@", (255, 255, 255))
 	shopkeeper = Entity(screen_width // 2 - 5, screen_height // 2, "@", (255, 255, 0))
 	entities = {player, shopkeeper}
 
-	engine = Engine(entities, event_handler, player)
+	game_map = generate_dungeon(room_count_max=room_count_max, room_size_min=room_size_min, room_size_max=room_size_max, map_width=map_width, map_height=map_height, player=player)
+
+	event_handler = EventHandler()
+
+	engine = Engine(entities, event_handler, game_map, player)
 
 	with tcod.context.new_terminal(
 		screen_width,

source/procgen.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import random
+from typing import Iterator, List, Tuple, TYPE_CHECKING
+
+import tcod
+
+from game_map import GameMap
+import tile_types
+
+if TYPE_CHECKING:
+	from entity import Entity
+
+class RectangularRoom:
+	def __init__(self, x: int, y: int, width: int, height: int):
+		self.x1 = x
+		self.y1 = y
+		self.x2 = x + width
+		self.y2 = y + height
+	
+	@property
+	def center(self) -> Tuple[int, int]:
+		center_x = (self.x1 + self.x2) // 2
+		center_y = (self.y1 + self.y2) // 2
+
+		return center_x, center_y
+	
+	@property
+	def inner(self) -> Tuple[slice, slice]:
+		return slice(self.x1 + 1, self.x2), slice(self.y1 + 1, self.y2)
+
+	def intersects(self, other: RectangularRoom) -> bool:
+		return (
+			self.x1 <= other.x2 and
+			self.x2 >= other.x1 and
+			self.y1 <= other.y2 and
+			self.y2 >= other.y1
+		)
+
+def tunnel_between(start: Tuple[int, int], end: Tuple[int, int]) -> Iterator[Tuple[int, int]]:
+	x1, y1 = start
+	x2, y2 = end
+
+	if random.random() < 0.5:
+		corner_x, corner_y = x2, y1
+	else:
+		corner_x, corner_y = x1, y2
+	
+	for x, y in tcod.los.bresenham((x1, y1), (corner_x, corner_y)).tolist():
+		yield x, y
+	for x, y in tcod.los.bresenham((corner_x, corner_y), (x2, y2)).tolist():
+		yield x, y
+
+def generate_dungeon(room_count_max: int, room_size_min: int, room_size_max: int, map_width: int, map_height: int, player: Entity) -> GameMap:
+	dungeon = GameMap(map_width, map_height)
+
+	rooms: List[RectangularRoom] = []
+
+	for r in range(room_count_max):
+		room_width = random.randint(room_size_min, room_size_max)
+		room_height = random.randint(room_size_min, room_size_max)
+
+		x = random.randint(0, dungeon.width - room_width - 1)
+		y = random.randint(0, dungeon.height - room_height - 1)
+
+		new_room = RectangularRoom(x, y, room_width, room_height)
+
+		if any(new_room.intersects(other_room) for other_room in rooms):
+			continue
+		
+		dungeon.tiles[new_room.inner] = tile_types.floor
+
+		if len(rooms) == 0:
+			player.x, player.y = new_room.center
+		else:
+			for x, y in tunnel_between(rooms[-1].center, new_room.center):
+				dungeon.tiles[x, y] = tile_types.floor
+		
+		rooms.append(new_room)
+
+	return dungeon

source/tile_types.py

@@ -22,7 +22,7 @@ tile_dt = np.dtype(
 
 def new_tile(*, walkable: int, transparent: int, dark: Tuple[int, Tuple[int, int, int], Tuple[int, int, int]], ) -> np.ndarray:
 	"""Helper function for defining individual tile types """
-    return np.array((walkable, transparent, dark), dtype=tile_dt)
+	return np.array((walkable, transparent, dark), dtype=tile_dt)
 
 
 floor = new_tile(walkable=True, transparent=True, dark=(ord(" "), (255, 255, 255), (50, 50, 150)))