Mouseover and log scroll added

Part 7 finished

source/engine.py

@@ -3,31 +3,37 @@ from tcod.console import Console
 from tcod.map import compute_fov
 
 from message_log import Message, MessageLog
-from render_functions import render_hp_bar
+from render_functions import render_hp_bar, render_names_at_location
 
-import entity_types
 from floor_map import FloorMap #TODO: replace with "DungeonMap"
 
 class Engine:
-	def __init__(self, floor_map: FloorMap, intro_msg: Message = None):
+	def __init__(self, floor_map: FloorMap, intro_msg: Message = None, ui_width: int = None, ui_height: int = None):
-		from event_handler import InGameEventHandler
+		#events
-		self.event_handler = InGameEventHandler(self)
+		from event_handler import InGameHandler
+		self.event_handler = InGameHandler(self)
+		self.mouse_location = (0, 0)
+
+		#map
 		self.floor_map = floor_map
 		self.floor_map.engine = self #references everywhere!
 
+		#messages
 		self.message_log = MessageLog()
 		if intro_msg:
 			self.message_log.push_message(intro_msg)
 
 		#grab the player object
 		self.player = self.floor_map.player
+		self.ui_width = floor_map.width if ui_width is None else ui_width
+		self.ui_height = 0 if ui_height is None else ui_height
 
 		#kick off the render
 		self.update_fov()
 
 	def run_loop(self, context: Context, console: Console) -> None:
 		while True:
-			if self.event_handler.handle_events():
+			if self.event_handler.handle_events(context):
 				self.handle_entities()
 
 			self.handle_rendering(context, console)
@@ -47,18 +53,28 @@ class Engine:
 		#UI
 		render_hp_bar(
 			console = console,
+			x = 0,
+			y = self.floor_map.height,
 			current_value = self.player.fighter.current_hp,
 			max_value = self.player.fighter.maximum_hp,
-			total_width = 20
+			total_width = self.ui_width // 2,
+		)
+		render_names_at_location(
+			console = console,
+			x = 1,
+			y = self.floor_map.height + 2,
+			engine = self,
 		)
 		self.message_log.render(
 			console=console,
-			x=21,
+			x=self.ui_width // 2,
-			y=45 - 5,
+			y=self.floor_map.height,
-			width = 40,
+			width = self.ui_width // 2,
-			height = 5
+			height = self.ui_height,
 		)
 
+		self.event_handler.render(console)
+
 		#send to the screen
 		context.present(console)
 		console.clear()

source/event_handler.py

@@ -47,25 +47,34 @@ WAIT_KEYS = {
 	tcod.event.KeySym.CLEAR,
 }
 
+CURSOR_SCROLL_KEYS = {
+	tcod.event.KeySym.UP: -1,
+	tcod.event.KeySym.DOWN: 1,
+	tcod.event.KeySym.PAGEUP: -10,
+	tcod.event.KeySym.PAGEDOWN: 10,
+
+	tcod.event.KeySym.KP_2: 1,
+	tcod.event.KeySym.KP_8: -1,
+}
+
 #event handler is one part of the engine
 class EventHandler(tcod.event.EventDispatch[BaseAction]):
 	def __init__(self, engine: Engine):
 		super().__init__()
 		self.engine = engine
 
+	def render(self, console: tcod.console.Console) -> None:
+		pass #no-op
+
 	#callbacks
 	def ev_quit(self, event: tcod.event.Quit) -> Optional[BaseAction]:
 		return QuitAction()
 
-	def handle_events(self) -> bool:
+	def handle_events(self, context: tcod.context.Context) -> bool:
-		raise NotImplementedError()
-
-
-class InGameEventHandler(EventHandler):
-	def handle_events(self) -> bool:
 		result = False
 
 		for event in tcod.event.wait():
+			context.convert_event(event)
 			action = self.dispatch(event)
 
 			if action is None:
@@ -75,6 +84,8 @@ class InGameEventHandler(EventHandler):
 
 		return result
 
+
+class InGameHandler(EventHandler):
 	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
 		key = event.sym #SDL stuff, neat.
 
@@ -91,21 +102,15 @@ class InGameEventHandler(EventHandler):
 		if key in WAIT_KEYS:
 			return WaitAction(player)
 
+		if key == tcod.event.KeySym.v:
+			self.engine.event_handler = LogHistoryViewer(self.engine)
 
-class GameOverEventHandler(EventHandler):
+	def ev_mousemotion(self, event: tcod.event.MouseMotion) -> None:
-	def handle_events(self) -> bool:
+		if self.engine.floor_map.in_bounds(event.tile.x, event.tile.y):
-		result = False
+			self.engine.mouse_location = event.tile.x, event.tile.y
 
-		for event in tcod.event.wait():
-			action = self.dispatch(event)
-
-			if action is None:
-				continue
-
-			result |= action.apply()
-
-		return result
 
+class GameOverHandler(EventHandler):
 	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
 		key = event.sym #SDL stuff, neat.
 
@@ -114,3 +119,46 @@ class GameOverEventHandler(EventHandler):
 			return QuitAction()
 
 		return None
+
+
+class LogHistoryViewer(EventHandler):
+	def __init__(self, engine: Engine):
+		super().__init__(engine)
+		self.log_length = len(engine.message_log.messages)
+		self.cursor = self.log_length - 1
+
+	def render(self, console: tcod.console.Console) -> None:
+		super().render(console)
+
+		log_console = tcod.console.Console(console.width - 6, console.height - 6)
+
+		#custom...
+		log_console.draw_frame(0, 0, log_console.width, log_console.height)
+		log_console.print_box(
+			0, 0, log_console.width, 1, "Message History", alignment=tcod.constants.CENTER
+		)
+		self.engine.message_log.render_messages(
+			log_console,
+			1, 1,
+			log_console.width - 2, log_console.height - 2,
+			self.engine.message_log.messages[:self.cursor + 1]
+		)
+		log_console.blit(console, 3, 3) #into the middle
+
+	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
+		if event.sym in CURSOR_SCROLL_KEYS:
+			adjust = CURSOR_SCROLL_KEYS[event.sym]
+			if adjust < 0 and self.cursor == 0:
+				pass #do nothing
+			elif adjust > 0 and self.cursor == self.log_length - 1:
+				pass #do nothing
+			else:
+				self.cursor = max(0, min(self.log_length - 1, self.cursor + adjust)) #TODO: nicer scroll down
+
+		elif event.sym == tcod.event.KeySym.HOME:
+			self.cursor = 0
+		elif event.sym == tcod.event.KeySym.END:
+			self.cursor = self.log_length - 1
+		else:
+			#return to the game
+			self.engine.event_handler = InGameHandler(self.engine)

source/main.py

@@ -7,29 +7,31 @@ from message_log import Message
 import colors
 
 def main() -> None:
+	#screen dimensions depend partially on the tileset
+	tileset = tcod.tileset.load_tilesheet("assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD)
+
+	#how big is the map's dimensions
+	map_width = 80
+	map_height = 40
+
+	ui_height = 5
+
 	#tcod stuff
 	context = tcod.context.new(
-		columns = 80,
+		columns = map_width,
-		rows = 45,
+		rows = map_height,
-		tileset = tcod.tileset.load_tilesheet("assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD),
+		tileset = tileset,
 		title = "Stepwise Roguelike",
 		vsync = True
 	)
 
-	w, h = context.recommended_console_size(min_columns=10, min_rows=10)
+	console = context.new_console(map_width, map_height + ui_height, order="F")
-
-	print (w,h)
-
-	console = tcod.console.Console(
-		width = w,
-		height = h + 5,
-		order = "F"
-	)
 
 	engine = Engine(
 		#is created externally, because
-		floor_map = generate_floor_map(80, 45, 10, 10),
+		floor_map = generate_floor_map(map_width, map_height, room_width_max=12, room_height_max=12),
-		intro_msg = Message("Welcome to the Cave of Gobbos!", colors.welcome_text)
+		intro_msg = Message("Welcome to the Cave of Gobbos!", colors.welcome_text),
+		ui_height = ui_height,
 	)
 
 	#game loop that never returns

source/render_functions.py

@@ -1,15 +1,37 @@
 from __future__ import annotations
 
-import colors
+from typing import Any
 
 from tcod.console import Console
 
-def render_hp_bar(console: Console, current_value: int, max_value: int, total_width: int) -> None:
+import colors
+from floor_map import FloorMap
+
+#utils
+def get_names_at(x: int, y: int, floor_map: FloorMap) -> str:
+	if not floor_map.in_bounds(x, y) or not floor_map.visible[x, y]:
+		return ""
+
+	names = ", ".join(
+		entity.name for entity in floor_map.entities if entity.x == x and entity.y == y
+	)
+
+	return names
+
+#direct rendering functions
+def render_hp_bar(console: Console, x: int, y: int, current_value: int, max_value: int, total_width: int) -> None:
 	bar_width = int(float(current_value) / max_value * total_width)
 
-	console.draw_rect(x=0, y=45, width=total_width, height=1, ch=1, bg=colors.bar_empty)
+	console.draw_rect(x=x, y=y, width=total_width, height=1, ch=1, bg=colors.bar_empty)
 
 	if bar_width > 0:
-		console.draw_rect(x=0, y=45, width=bar_width, height=1, ch=1, bg=colors.bar_filled)
+		console.draw_rect(x=x, y=y, width=bar_width, height=1, ch=1, bg=colors.bar_filled)
 
-	console.print(x=1, y=45, string=f"HP: {current_value}/{max_value}", fg=colors.bar_text)
+	console.print(x=x + 1, y=y, string=f"HP: {current_value}/{max_value}", fg=colors.bar_text)
+
+def render_names_at_location(console: Console, x: int, y: int, engine: Any) -> None:
+	mouse_x, mouse_y = engine.mouse_location
+
+	names: str = get_names_at(mouse_x, mouse_y, engine.floor_map)
+
+	console.print(x=x, y=y, string=names)