Reworked the code to work better after tutorial stuff

README.md

@@ -4,8 +4,12 @@
 
 The "water meter" is always visible, and ticks down each time you take an action. When it hits zero, you die.
 
+This will probably see some iteration.
+
 ## Link
 
+https://python-tcod.readthedocs.io/en/latest/
+
 I'm working from this:
 
 https://rogueliketutorials.com/tutorials/tcod/v2/part-4/

source/actions.py

@@ -1,37 +1,26 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
 from engine import Engine
+
 from entity import Entity
 
-class Action: #lawsuit?
+class Action:
-	def perform(self, engine: Engine, entity: Entity) -> None:
+	def apply(self, engine: Engine) -> None:
-		"Oh look, the visitor pattern!"
 		raise NotImplementedError()
 
-
+class QuitAction(Action):
-class EscapeAction(Action):
+	def apply(self, engine: Engine) -> None:
-	def perform(self, engine: Engine, entity: Entity) -> None:
 		raise SystemExit()
 
-
+class MoveAction(Action):
-class MovementAction(Action):
+	def __init__(self, entity: Entity, xdir: int, ydir: int):
-	def __init__(self, dx: int, dy: int):
 		super().__init__()
+		self.entity = entity
+		self.xdir = xdir
+		self.ydir = ydir
 
-		self.dx = dx
+	def apply(self, engine: Engine) -> None:
-		self.dy = dy
+		x = self.entity.x + self.xdir
+		y = self.entity.y + self.ydir
 
-	def perform(self, engine: Engine, entity: Entity) -> None:
+		#TODO: bounds checks
-		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.entity.set_pos(x, y)

source/engine.py

@@ -1,20 +1,16 @@
-from typing import Set, Iterable, Any
+from typing import Any, Iterable
 
 from tcod.context import Context
 from tcod.console import Console
 
-from event_handler import EventHandler
-from actions import EscapeAction, MovementAction
-
 from entity import Entity
-from game_map import GameMap
 
 class Engine:
-	def __init__(self, entities: Set[Entity], event_handler: EventHandler, game_map: GameMap, player: Entity):
+	def __init__(self):
-		self.entities = entities
+		from event_handler import EventHandler
-		self.event_handler = event_handler
+		self.event_handler = EventHandler(self)
-		self.game_map = game_map
+
-		self.player = player
+		self.player = Entity(0, 0, "@", (255, 255, 255))
 
 	def handle_events(self, events: Iterable[Any]) -> None:
 		for event in events:
@@ -23,13 +19,17 @@ class Engine:
 			if action is None:
 				continue
 			
-			action.perform(self, self.player)
+			action.apply(Engine)
 	
-	def render(self, console: Console, context: Context) -> None:
+	def render(self, context: Context, console: Console) -> None:
-		self.game_map.render(console)
+		#TODO: render map
 
-		for entity in self.entities:
+		#TODO: render entities
-			console.print(entity.x, entity.y, entity.char, fg=entity.color)
+		# for entity in self.entities:
+		# 	console.print(entity.x, entity.y, entity.char, fg=entity.color)
 
+		console.print(self.player.x, self.player.y, self.player.char, fg=self.player.color)
+
+		#send to the screen
 		context.present(console)
 		console.clear()

source/entity.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-
 class Entity:
 	def __init__(self, x: int, y: int, char: str, color: Tuple[int, int, int]):
 		self.x = x
@@ -8,7 +7,6 @@ class Entity:
 		self.char = char
 		self.color = color
 
-    def set_pos(self, dx: int, dy: int) -> None:
+	def set_pos(self, x: int, y: int) -> None:
-        # Move the entity by a given amount
+		self.x = x
-        self.x = dx
+		self.y = y
-        self.y = dy

source/event_handler.py

@@ -1,31 +1,34 @@
 from typing import Optional
 
-import tcod.event
+import tcod
-
-from actions import Action, EscapeAction, MovementAction
 
+from actions import Action, QuitAction, MoveAction
+from engine import Engine
 
 class EventHandler(tcod.event.EventDispatch[Action]):
+	def __init__(self, engine: Engine):
+		super().__init__()
+		self.engine = engine
+
 	def ev_quit(self, event: tcod.event.Quit) -> Optional[Action]:
-        raise SystemExit()
+		return QuitAction()
 
 	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[Action]:
-        action: Optional[Action] = None
+		key = event.sym #SDL stuff, neat.
-
-        key = event.sym
 
 		#parse input
-        if key == tcod.event.KeySym.UP:
+		match key:
-            action = MovementAction(dx=0, dy=-1)
+			case tcod.event.KeySym.ESCAPE:
-        elif key == tcod.event.KeySym.DOWN:
+				return QuitAction()
-            action = MovementAction(dx=0, dy=1)
-        elif key == tcod.event.KeySym.LEFT:
-            action = MovementAction(dx=-1, dy=0)
-        elif key == tcod.event.KeySym.RIGHT:
-            action = MovementAction(dx=1, dy=0)
 
-        elif key == tcod.event.KeySym.ESCAPE:
+			case tcod.event.KeySym.UP:
-            action = EscapeAction()
+				return MoveAction(self.engine.player, xdir = 0, ydir = -1)
+			case tcod.event.KeySym.DOWN:
+				return MoveAction(self.engine.player, xdir = 0, ydir = 1)
+			case tcod.event.KeySym.LEFT:
+				return MoveAction(self.engine.player, xdir = -1, ydir = 0)
+			case tcod.event.KeySym.RIGHT:
+				return MoveAction(self.engine.player, xdir = 1, ydir = 0)
 
-        # No valid key was pressed
+			case _:
-        return action
+				return None

source/game_map.py

@@ -1,18 +0,0 @@
-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

@@ -2,49 +2,37 @@
 import tcod
 
 from engine import Engine
-from entity import Entity
-from procgen import generate_dungeon
-from event_handler import EventHandler
-
 
 def main() -> None:
-	#Initial values
+	#assets
-	screen_width = 80
-	screen_height = 50
-
-	map_width = 80
-	map_height = 45
-
-	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
+	context = tcod.context.new(
-	player = Entity(screen_width // 2, screen_height // 2, "@", (255, 255, 255))
+		columns = 40,
-	shopkeeper = Entity(screen_width // 2 - 5, screen_height // 2, "@", (255, 255, 0))
+		rows = 20,
-	entities = {player, shopkeeper}
-
-	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,
-		screen_height,
 		tileset = tileset,
-		title="Stepwise Tutorial",
+		title = "Stepwise Roguelike",
-		vsync=True,
+		vsync = True
-	) as context:
+	)
-		root_console = tcod.console.Console(screen_width, screen_height, order="F")
+
+	w, h = context.recommended_console_size(min_columns=10, min_rows=10)
+
+	print(w, h)
+
+	console = tcod.console.Console(
+		width = w,
+		height = h,
+		order = "F"
+	)
+
+	engine = Engine()
+
+	# game loop
 	while True:
-			engine.render(console = root_console, context = context)
+		engine.render(context, console)
 		events = tcod.event.wait()
 		engine.handle_events(events)
 
-
+# this seems odd to me
 if __name__ == "__main__":
 	main()

source/procgen.py

@@ -1,81 +0,0 @@
-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

@@ -1,29 +0,0 @@
-from typing import Tuple
-
-import numpy as np #libtcod is built on this
-
-#data types
-graphic_dt = np.dtype(
-	[
-		("ch", np.int32),
-		("fg", "3B"),
-		("bg", "3B")
-	]
-)
-
-tile_dt = np.dtype(
-    [
-        ("walkable", np.bool),  # True if this tile can be walked over.
-        ("transparent", np.bool),  # True if this tile doesn't block FOV.
-        ("dark", graphic_dt),  # Graphics for when this tile is not in FOV.
-    ]
-)
-
-
-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)
-
-
-floor = new_tile(walkable=True, transparent=True, dark=(ord(" "), (255, 255, 255), (50, 50, 150)))
-wall = new_tile(walkable=False, transparent=False, dark=(ord(" "), (255, 255, 255), (0, 0, 100)))