Implement entity examples

Author: HexDecimal

.vscode/settings.json

@@ -14,6 +14,8 @@
     },
     "cSpell.words": [
         "isort",
+        "PAGEDOWN",
+        "PAGEUP",
         "tcod",
         "tileset",
         "tilesheet"

g.py

@@ -3,6 +3,7 @@
 
 import tcod.console
 import tcod.context
+import tcod.ecs
 
 import game.state
 
@@ -14,3 +15,6 @@
 
 states: list[game.state.State] = []
 """A stack of states with the last item being the active state."""
+
+world: tcod.ecs.Registry
+"""The active ECS registry and current session."""

game/__init__.py

@@ -0,0 +1 @@
+"""Game namespace package."""

game/components.py

@@ -0,0 +1,44 @@
+"""Collection of common components."""
+from __future__ import annotations
+
+from typing import Final, Self
+
+import attrs
+import tcod.ecs.callbacks
+from tcod.ecs import Entity
+
+
+@attrs.define(frozen=True)
+class Position:
+    """An entities position."""
+
+    x: int
+    y: int
+
+    def __add__(self, direction: tuple[int, int]) -> Self:
+        """Add a vector to this position."""
+        x, y = direction
+        return self.__class__(self.x + x, self.y + y)
+
+
+@tcod.ecs.callbacks.register_component_changed(component=Position)
+def on_position_changed(entity: Entity, old: Position | None, new: Position | None) -> None:
+    """Mirror position components as a tag."""
+    if old == new:
+        return
+    if old is not None:
+        entity.tags.discard(old)
+    if new is not None:
+        entity.tags.add(new)
+
+
+@attrs.define(frozen=True)
+class Graphic:
+    """An entities icon and color."""
+
+    ch: int = ord("!")
+    fg: tuple[int, int, int] = (255, 255, 255)
+
+
+Gold: Final = ("Gold", int)
+"""Amount of gold."""

game/state.py

@@ -10,6 +10,8 @@
 class State(Protocol):
     """An abstract game state."""
 
+    __slots__ = ()
+
     def on_event(self, event: tcod.event.Event) -> None:
         """Called on events."""
 

game/state_tools.py

@@ -1,4 +1,6 @@
 """State handling functions."""
+from __future__ import annotations
+
 import tcod.console
 
 import g
@@ -18,6 +20,5 @@ def main_loop() -> None:
     while g.states:
         main_draw()
         for event in tcod.event.wait():
-            print(event)
             if g.states:
                 g.states[-1].on_event(event)

game/states.py

@@ -1,35 +1,72 @@
 """A collection of game states."""
 from __future__ import annotations
 
+from typing import Final
+
 import attrs
 import tcod.console
 import tcod.event
 from tcod.event import KeySym
 
+import g
+from game.components import Gold, Graphic, Position
+from game.tags import IsItem, IsPlayer
+
+DIRECTION_KEYS: Final = {
+    # Arrow keys
+    KeySym.LEFT: (-1, 0),
+    KeySym.RIGHT: (1, 0),
+    KeySym.UP: (0, -1),
+    KeySym.DOWN: (0, 1),
+    # Arrow key diagonals
+    KeySym.HOME: (-1, -1),
+    KeySym.END: (-1, 1),
+    KeySym.PAGEUP: (1, -1),
+    KeySym.PAGEDOWN: (1, 1),
+    # Keypad
+    KeySym.KP_4: (-1, 0),
+    KeySym.KP_6: (1, 0),
+    KeySym.KP_8: (0, -1),
+    KeySym.KP_2: (0, 1),
+    KeySym.KP_7: (-1, -1),
+    KeySym.KP_1: (-1, 1),
+    KeySym.KP_9: (1, -1),
+    KeySym.KP_3: (1, 1),
+    # VI keys
+    KeySym.h: (-1, 0),
+    KeySym.l: (1, 0),
+    KeySym.k: (0, -1),
+    KeySym.j: (0, 1),
+    KeySym.y: (-1, -1),
+    KeySym.b: (-1, 1),
+    KeySym.u: (1, -1),
+    KeySym.n: (1, 1),
+}
 
-@attrs.define(eq=False)
-class ExampleState:
-    """Example state with a hard-coded player position."""
 
-    player_x: int
-    """Player X position, left-most position is zero."""
-    player_y: int
-    """Player Y position, top-most position is zero."""
+@attrs.define()
+class InGame:
+    """Primary in-game state."""
 
     def on_event(self, event: tcod.event.Event) -> None:
-        """Move the player on events and handle exiting. Movement is hard-coded."""
+        """Handle events for the in-game state."""
+        (player,) = g.world.Q.all_of(tags=[IsPlayer])
         match event:
             case tcod.event.Quit():
                 raise SystemExit()
-            case tcod.event.KeyDown(sym=KeySym.LEFT):
-                self.player_x -= 1
-            case tcod.event.KeyDown(sym=KeySym.RIGHT):
-                self.player_x += 1
-            case tcod.event.KeyDown(sym=KeySym.UP):
-                self.player_y -= 1
-            case tcod.event.KeyDown(sym=KeySym.DOWN):
-                self.player_y += 1
+            case tcod.event.KeyDown(sym=sym) if sym in DIRECTION_KEYS:
+                player.components[Position] += DIRECTION_KEYS[sym]
+                # Auto pickup gold
+                for gold in g.world.Q.all_of(components=[Gold], tags=[player.components[Position], IsItem]):
+                    player.components[Gold] += gold.components[Gold]
+                    print(f"Picked up {gold.components[Gold]}g, total: {player.components[Gold]}g")
+                    gold.clear()
 
     def on_draw(self, console: tcod.console.Console) -> None:
-        """Draw the player with print. Bounds do not need to be checked with this function."""
-        console.print(self.player_x, self.player_y, "@")
+        """Draw the standard screen."""
+        for entity in g.world.Q.all_of(components=[Position, Graphic]):
+            pos = entity.components[Position]
+            if not (0 <= pos.x < console.width and 0 <= pos.y < console.height):
+                continue
+            graphic = entity.components[Graphic]
+            console.rgb[["ch", "fg"]][pos.y, pos.x] = graphic.ch, graphic.fg

game/tags.py

@@ -0,0 +1,13 @@
+"""Collection of common tags."""
+from __future__ import annotations
+
+from typing import Final
+
+IsPlayer: Final = "IsPlayer"
+"""Entity is the player."""
+
+IsActor: Final = "IsActor"
+"""Entity is an actor."""
+
+IsItem: Final = "IsItem"
+"""Entity is an item."""

game/world_tools.py

@@ -0,0 +1,31 @@
+"""Functions for working with worlds."""
+from __future__ import annotations
+
+from random import Random
+
+from tcod.ecs import Registry
+
+from game.components import Gold, Graphic, Position
+from game.tags import IsActor, IsItem, IsPlayer
+
+
+def new_world() -> Registry:
+    """Return a freshly generated world."""
+    world = Registry()
+
+    rng = world[None].components[Random] = Random()
+
+    player = world[object()]
+    player.components[Position] = Position(5, 5)
+    player.components[Graphic] = Graphic(ord("@"))
+    player.components[Gold] = 0
+    player.tags |= {IsPlayer, IsActor}
+
+    for _ in range(10):
+        gold = world[object()]
+        gold.components[Position] = Position(rng.randint(0, 20), rng.randint(0, 20))
+        gold.components[Graphic] = Graphic(ord("$"), fg=(255, 255, 0))
+        gold.components[Gold] = rng.randint(1, 10)
+        gold.tags |= {IsItem}
+
+    return world

main.py

@@ -4,12 +4,12 @@
 
 import tcod.console
 import tcod.context
-import tcod.event
 import tcod.tileset
 
 import g
 import game.state_tools
 import game.states
+import game.world_tools
 
 
 def main() -> None:
@@ -19,7 +19,8 @@ def main() -> None:
     )
     tcod.tileset.procedural_block_elements(tileset=tileset)
     g.console = tcod.console.Console(80, 50)
-    g.states = [game.states.ExampleState(player_x=g.console.width // 2, player_y=g.console.height // 2)]
+    g.states = [game.states.InGame()]
+    g.world = game.world_tools.new_world()
     with tcod.context.new(console=g.console, tileset=tileset) as g.context:
         game.state_tools.main_loop()