Move the roguebasin package to erynrl

erynrl/object.py

@@ -0,0 +1,173 @@
+# Eryn Wells <eryn@erynwells.me>
+
+from enum import Enum
+from typing import TYPE_CHECKING, Optional, Tuple, Type
+
+import tcod
+
+from . import items
+from .components import Fighter
+from .geometry import Point
+from .monsters import Species
+
+if TYPE_CHECKING:
+    from .ai import AI
+
+class RenderOrder(Enum):
+    '''
+    These values indicate the order that an Entity should be rendered. Higher values are rendered later and therefore on
+    top of items at with lower orderings.
+    '''
+    ITEM = 1000
+    ACTOR = 2000
+    HERO = 3000
+
+class Entity:
+    '''A single-tile drawable entity with a symbol and position
+
+    Attributes
+    ----------
+    position : Point
+        The Entity's location on the map
+    foreground : Tuple[int, int, int]
+        The foreground color used to render this Entity
+    background : Tuple[int, int, int], optional
+        The background color used to render this Entity
+    symbol : str
+        A single character string that represents this character on the map
+    ai : Type[AI], optional
+        If an entity can act on its own behalf, an instance of an AI class
+    blocks_movement : bool
+        True if this Entity blocks other Entities from moving through its position
+    '''
+
+    def __init__(self, symbol: str, *,
+                 position: Optional[Point] = None,
+                 blocks_movement: Optional[bool] = True,
+                 render_order: RenderOrder = RenderOrder.ITEM,
+                 fg: Optional[Tuple[int, int, int]] = None,
+                 bg: Optional[Tuple[int, int, int]] = None):
+        self.position = position if position else Point()
+        self.foreground = fg if fg else (255, 255, 255)
+        self.background = bg
+        self.symbol = symbol
+        self.blocks_movement = blocks_movement
+        self.render_order = render_order
+
+    def print_to_console(self, console: tcod.Console) -> None:
+        '''Render this Entity to the console'''
+        console.print(x=self.position.x, y=self.position.y, string=self.symbol, fg=self.foreground, bg=self.background)
+
+    def __str__(self) -> str:
+        return f'{self.symbol}[{self.position}]'
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.symbol!r}, position={self.position!r}, fg={self.foreground!r}, bg={self.background!r})'
+
+class Actor(Entity):
+    def __init__(self, symbol: str, *,
+                 position: Optional[Point] = None,
+                 blocks_movement: Optional[bool] = True,
+                 render_order: RenderOrder = RenderOrder.ACTOR,
+                 ai: Optional[Type['AI']] = None,
+                 fighter: Optional[Fighter] = None,
+                 fg: Optional[Tuple[int, int, int]] = None,
+                 bg: Optional[Tuple[int, int, int]] = None):
+        super().__init__(symbol, position=position, blocks_movement=blocks_movement, fg=fg, bg=bg, render_order=render_order)
+
+        # Components
+        self.ai = ai
+        self.fighter = fighter
+
+    @property
+    def name(self) -> str:
+        return 'Actor'
+
+    @property
+    def sight_radius(self) -> int:
+        '''The number of tiles this entity can see around itself'''
+        return 0
+
+    @property
+    def yields_corpse_on_death(self) -> bool:
+        '''True if this Actor should produce a corpse when it dies'''
+        return False
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.symbol!r}, position={self.position!r}, fighter={self.fighter!r}, ai={self.ai!r}, fg={self.foreground!r}, bg={self.background!r})'
+
+class Hero(Actor):
+    '''The hero, the player character'''
+
+    def __init__(self, position: Point):
+        super().__init__('@',
+             position=position,
+             fighter=Fighter(maximum_hit_points=30, attack_power=5, defense=2),
+             render_order=RenderOrder.HERO,
+             fg=tuple(tcod.white))
+
+    @property
+    def name(self) -> str:
+        return 'Hero'
+
+    @property
+    def sight_radius(self) -> int:
+        # TODO: Make this configurable
+        return 8
+
+    def __str__(self) -> str:
+        return f'{self.symbol}[{self.position}][{self.fighter.hit_points}/{self.fighter.maximum_hit_points}]'
+
+class Monster(Actor):
+    '''An instance of a Species'''
+
+    def __init__(self, species: Species, ai_class: Type['AI'], position: Point = None):
+        fighter = Fighter(
+            maximum_hit_points=species.maximum_hit_points,
+            attack_power=species.attack_power,
+            defense=species.defense)
+
+        super().__init__(
+            species.symbol,
+            ai=ai_class(self),
+            position=position,
+            fighter=fighter,
+            fg=species.foreground_color,
+            bg=species.background_color)
+
+        self.species = species
+
+    @property
+    def name(self) -> str:
+        return self.species.name
+
+    @property
+    def sight_radius(self) -> int:
+        return self.species.sight_radius
+
+    @property
+    def yields_corpse_on_death(self) -> bool:
+        return True
+
+    def __str__(self) -> str:
+        return f'{self.name} with {self.fighter.hit_points}/{self.fighter.maximum_hit_points} hp at {self.position}'
+
+class Item(Entity):
+    '''An instance of an Item'''
+
+    def __init__(self, kind: items.Item, position: Point = None, name: str = None):
+        super().__init__(kind.symbol,
+                         position=position,
+                         blocks_movement=False,
+                         render_order=RenderOrder.ITEM,
+                         fg=kind.foreground_color,
+                         bg=kind.background_color)
+        self.kind = kind
+        self._name = name
+
+    @property
+    def name(self) -> str:
+        '''The name of the item'''
+        if self._name:
+            return self._name
+        return self.kind.name