parts 4 and 5 done!

Author: jossse69

actions.py

@@ -19,20 +19,31 @@ def perform(self, engine: Engine, entity: Entity) -> None:
         """
         raise NotImplementedError()
 
+class ActionWithDirection(Action):
+    def __init__(self, dx: int, dy: int):
+        super().__init__()
+
+        self.dx = dx
+        self.dy = dy
 
+    def perform(self, engine: Engine, entity: Entity) -> None:
+        raise NotImplementedError()
 
 class EscapeAction(Action):
     def perform(self, engine: Engine, entity: Entity) -> None:
         raise SystemExit()
 
+class MeleeAction(ActionWithDirection):
+    def perform(self, engine: Engine, entity: Entity) -> None:
+        dest_x = entity.x + self.dx
+        dest_y = entity.y + self.dy
+        target = engine.game_map.get_blocking_entity_at_location(dest_x, dest_y)
+        if not target:
+            return  # No entity to attack.
 
-class MovementAction(Action):
-    def __init__(self, dx: int, dy: int):
-        super().__init__()
-
-        self.dx = dx
-        self.dy = dy
+        print(f"You punch the {target.name}, it does not seem to be doing much damage...")
 
+class MovementAction(ActionWithDirection):
     def perform(self, engine: Engine, entity: Entity) -> None:
         dest_x = entity.x + self.dx
         dest_y = entity.y + self.dy
@@ -41,5 +52,20 @@ def perform(self, engine: Engine, entity: Entity) -> None:
             return  # Destination is out of bounds.
         if not engine.game_map.tiles["walkable"][dest_x, dest_y]:
             return  # Destination is blocked by a tile.
+        if engine.game_map.get_blocking_entity_at_location(dest_x, dest_y):
+            return  # Destination is blocked by an entity.
+
+
+        entity.move(self.dx, self.dy)
+
+
+class BumpAction(ActionWithDirection):
+    def perform(self, engine: Engine, entity: Entity) -> None:
+        dest_x = entity.x + self.dx
+        dest_y = entity.y + self.dy
+
+        if engine.game_map.get_blocking_entity_at_location(dest_x, dest_y):
+            return MeleeAction(self.dx, self.dy).perform(engine, entity)
 
-        entity.move(self.dx, self.dy)
+        else:
+            return MovementAction(self.dx, self.dy).perform(engine, entity)

engine.py

@@ -1,19 +1,25 @@
-from typing import Set, Iterable, Any
+from typing import Iterable, Any
 
 from tcod.context import Context
 from tcod.console import Console
+from tcod.map import compute_fov
+import tcod.constants
 
 from entity import Entity
 from game_map import GameMap
 from input_handlers import EventHandler
 
 
 class Engine:
-    def __init__(self, entities: Set[Entity], event_handler: EventHandler, game_map: GameMap, player: Entity):
-        self.entities = entities
+    def __init__(self, event_handler: EventHandler, game_map: GameMap, player: Entity):
         self.event_handler = event_handler
         self.game_map = game_map
         self.player = player
+        self.update_fov()
+
+    def handle_enemy_turns(self) -> None:
+        for entity in self.game_map.entities - {self.player}:
+            print(f'The {entity.name} wonders when it will get to take a real turn.')
 
     def handle_events(self, events: Iterable[Any]) -> None:
         for event in events:
@@ -23,13 +29,25 @@ def handle_events(self, events: Iterable[Any]) -> None:
                 continue
 
             action.perform(self, self.player)
+            self.handle_enemy_turns()
+            self.update_fov() # Update the FOV before the players next action.
+
+    def update_fov(self) -> None:
+        """Recompute the visible area based on the players point of view."""
+        self.game_map.visible[:] = compute_fov(
+            self.game_map.tiles["transparent"],
+            (self.player.x, self.player.y),
+            radius=8,
+            light_walls=True,
+            algorithm=tcod.constants.FOV_SHADOW
+        )
+        # If a tile is "visible" it should be added to "explored".
+        self.game_map.explored |= self.game_map.visible
+
 
     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)
-
         context.present(console)
 
         console.clear()

entity.py

@@ -1,15 +1,43 @@
-from typing import Tuple
+from __future__ import annotations
 
+import copy
+from typing import Tuple, TypeVar, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from game_map import GameMap
+
+T = TypeVar("T", bound="Entity")
 
 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]):
+    def __init__(
+        self,
+        x: int = 0,
+        y: int = 0,
+        char: str = "?",
+        color: Tuple[int, int, int] = (255, 255, 255),
+        name: str = "<Unnamed>",
+        blocks_movement: bool = False,
+    ):
+        """
+        Create a new entity with the given properties.
+        """
         self.x = x
         self.y = y
         self.char = char
         self.color = color
+        self.name = name
+        self.blocks_movement = blocks_movement
+
+    def spawn(self: T, gamemap: GameMap, x: int, y: int) -> T:
+        """Spawn a copy of this instance at the given location."""
+        clone = copy.deepcopy(self)
+        clone.x = x
+        clone.y = y
+        gamemap.entities.add(clone)
+        return clone
 
     def move(self, dx: int, dy: int) -> None:
         """

entity_factories.py

@@ -0,0 +1,6 @@
+from entity import Entity
+
+player = Entity(char="@", color=(255, 255, 0), name="Player", blocks_movement=True)
+
+smile_mold = Entity(char="m", color=(255, 80, 80), name="Slime Mold", blocks_movement=True)
+rusty_automaton = Entity(char="a", color=(200, 174, 137), name="Rusty Automaton", blocks_movement=True)

game_map.py

@@ -1,17 +1,36 @@
+from __future__ import annotations
+
+from typing import Iterable, Optional, TYPE_CHECKING
+
 import numpy as np  # type: ignore
 from tcod.console import Console
 
 import tile_types
 
+if TYPE_CHECKING:
+    from entity import Entity
 
 class GameMap:
-    def __init__(self, width: int, height: int):
+    def __init__(self, width: int, height: int, entities: Iterable[Entity] = ()):
+        self.entities = set(entities)
         self.width, self.height = width, height
         self.tiles = np.full((width, height), fill_value=tile_types.wall, order="F")
 
+        self.visible = np.full((width, height), fill_value=False, order="F")  # Tiles the player can currently see
+        self.explored = np.full((width, height), fill_value=False, order="F")  # Tiles the player has seen before
+
     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 get_blocking_entity_at_location(self, location_x: int, location_y: int) -> Optional[Entity]:
+        """Return the blocking entity at a given location, if any."""
+        for entity in self.entities:
+            if entity.blocks_movement and entity.x == location_x and entity.y == location_y:
+                return entity
+
+        return None
+
     def set_tile(self, x: int, y: int, tile: str) -> None:
         # if the tile has autotile then set the autotile'
         self.tiles[x, y] = tile
@@ -103,6 +122,23 @@ def update_tile_at(self, x: int, y: int, tile: str) -> None:
 
             # Set the first int if the "dark" nparray with the unicode of the ch
             tile["dark"]["ch"] = ord(ch)
+            tile["light"]["ch"] = ord(ch)
 
     def render(self, console: Console) -> None:
-        console.rgb[0:self.width, 0:self.height] = self.tiles["dark"]
+        """
+        Renders the map.
+
+        If a tile is in the "visible" array, then draw it with the "light" colors.
+        If it isn't, but it's in the "explored" array, then draw it with the "dark" colors.
+        Otherwise, the default is "SHROUD".
+        """
+        console.tiles_rgb[0:self.width, 0:self.height] = np.select(
+            condlist=[self.visible, self.explored],
+            choicelist=[self.tiles["light"], self.tiles["dark"]],
+            default=tile_types.SHROUD
+        )
+
+        for entity in self.entities:
+            # Only print entities that are in the FOV
+            if self.visible[entity.x, entity.y]:
+                console.print(x=entity.x, y=entity.y, string=entity.char, fg=entity.color)

input_handlers.py

@@ -2,7 +2,7 @@
 
 import tcod.event
 
-from actions import Action, EscapeAction, MovementAction
+from actions import Action, BumpAction, EscapeAction
 
 
 class EventHandler(tcod.event.EventDispatch[Action]):
@@ -15,13 +15,13 @@ def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[Action]:
         key = event.sym
 
         if key == tcod.event.KeySym.UP:
-            action = MovementAction(dx=0, dy=-1)
+            action = BumpAction(dx=0, dy=-1)
         elif key == tcod.event.KeySym.DOWN:
-            action = MovementAction(dx=0, dy=1)
+            action = BumpAction(dx=0, dy=1)
         elif key == tcod.event.KeySym.LEFT:
-            action = MovementAction(dx=-1, dy=0)
+            action = BumpAction(dx=-1, dy=0)
         elif key == tcod.event.KeySym.RIGHT:
-            action = MovementAction(dx=1, dy=0)
+            action = BumpAction(dx=1, dy=0)
 
         elif key == tcod.event.KeySym.ESCAPE:
             action = EscapeAction()

main.py

@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
 import tcod
+import copy
 
 from engine import Engine
 from entity import Entity
 from procgen import generate_dungeon
 from input_handlers import EventHandler
+import entity_factories
 
 def main():
     screen_width = 80
@@ -17,24 +19,24 @@ def main():
     map_width = 80
     map_height = 45
 
+    max_monsters_per_room = 2
 
     tileset = tcod.tileset.load_tilesheet("data/zaratustra_msx.png", 16, 16, tcod.tileset.CHARMAP_CP437)
 
     event_handler = EventHandler()
 
-    player = Entity(int(screen_width / 2), int(screen_height / 2), "@", (255, 255, 0))
-    entities = {player}
-
+    player = copy.deepcopy(entity_factories.player)
     game_map = generate_dungeon(
         max_rooms=max_rooms,
         room_min_size=room_min_size,
         room_max_size=room_max_size,
         map_width=map_width,
         map_height=map_height,
+        max_monsters_per_room=max_monsters_per_room,
         player=player
     )
 
-    engine = Engine(entities=entities, event_handler=event_handler, game_map=game_map, player=player)
+    engine = Engine(event_handler=event_handler, game_map=game_map, player=player)
 
     with tcod.context.new_terminal(
         screen_width,

procgen.py

@@ -6,6 +6,8 @@
 import tile_types
 import tcod
 
+import entity_factories
+
 if TYPE_CHECKING:
     from entity import Entity
 
@@ -37,6 +39,20 @@ def intersects(self, other: RectangularRoom) -> bool:
             and self.y2 >= other.y1
         )
 
+def place_entities(
+    room: RectangularRoom, dungeon: GameMap, maximum_monsters: int,
+) -> None:
+    number_of_monsters = random.randint(0, maximum_monsters)
+
+    for i in range(number_of_monsters):
+        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):
+            if random.random() < 0.8:
+                entity_factories.smile_mold.spawn(dungeon, x, y)
+            else:
+                entity_factories.rusty_automaton.spawn(dungeon, x, y)
 
 def tunnel_between(
     start: Tuple[int, int], end: Tuple[int, int]
@@ -64,10 +80,11 @@ def generate_dungeon(
     room_max_size: int,
     map_width: int,
     map_height: int,
+    max_monsters_per_room: int,
     player: Entity,
 ) -> GameMap:
     """Generate a new dungeon map."""
-    dungeon = GameMap(map_width, map_height)
+    dungeon = GameMap(map_width, map_height, entities=[player])
 
     rooms: List[RectangularRoom] = []
 
@@ -99,6 +116,8 @@ def generate_dungeon(
             for x, y in tunnel_between(rooms[-1].center, new_room.center):
                 dungeon.set_tile(x, y, tile_types.floor)
 
+        place_entities(new_room, dungeon, max_monsters_per_room)
+
         # Finally, append the new room to the list.
         rooms.append(new_room)
 

tile_types.py

@@ -17,25 +17,29 @@
         ("walkable", bool),  # True if this tile can be walked over.
         ("transparent", bool),  # True if this tile doesn't block FOV.
         ("dark", graphic_dt),  # Graphics for when this tile is not in FOV.
-        ("autotile", bool) # If the Tile will  be set to this symbols to make boders: ─│┌┐└┘
+        ("light", graphic_dt),  # Graphics for when the tile is in FOV.
+        ("autotile", bool), # If the Tile will  be set to this symbols to make boders: ─│┌┐└┘
     ]
 )
 
+# SHROUD represents unexplored, unseen tiles
+SHROUD = np.array((ord(" "), (255, 255, 255), (0, 0, 0)), dtype=graphic_dt)
 
 def new_tile(
     *,  # Enforce the use of keywords, so that parameter order doesn't matter.
     walkable: int,
     transparent: int,
     dark: Tuple[int, Tuple[int, int, int], Tuple[int, int, int]],
+    light: Tuple[int, Tuple[int, int, int], Tuple[int, int, int]],
     autotile: bool,
 ) -> np.ndarray:
     """Helper function for defining individual tile types """
-    return np.array((walkable, transparent, dark, autotile), dtype=tile_dt)
+    return np.array((walkable, transparent, dark, light, autotile), dtype=tile_dt)
 
 
 floor = new_tile(
-    walkable=True, transparent=True, dark=(ord("."), (102, 0, 51), (0, 0, 0)), autotile=False
+    walkable=True, transparent=True, light=(ord("."), (102, 0, 51), (0, 0, 0)), dark=(ord("."), (51, 51, 51), (0, 0, 0)), autotile=False
 )
 wall = new_tile(
-    walkable=False, transparent=False, dark=(ord(" "), (153, 0, 153), (0,0,0)), autotile=True
+    walkable=False, transparent=False, light=(ord(" "), (153, 0, 153), (0,0,0)), dark=(ord(" "), (51, 51, 51), (0, 0, 0)), autotile=True
 )