109 lines
3.6 KiB
Python
109 lines
3.6 KiB
Python
# Eryn Wells <eryn@erynwells.me>
|
|
|
|
'''Defines the core game engine.'''
|
|
|
|
import random
|
|
from dataclasses import dataclass
|
|
from typing import TYPE_CHECKING, MutableSet, NoReturn
|
|
|
|
import tcod
|
|
|
|
from . import log
|
|
from . import monsters
|
|
from .ai import HostileEnemy
|
|
from .events import MainGameEventHandler
|
|
from .geometry import Size
|
|
from .map import Map
|
|
from .object import Entity, Hero, Monster
|
|
|
|
if TYPE_CHECKING:
|
|
from .events import EventHandler
|
|
|
|
@dataclass
|
|
class Configuration:
|
|
map_size: Size
|
|
|
|
class Engine:
|
|
'''The main game engine.
|
|
|
|
This class provides the event handling, map drawing, and maintains the list of entities.
|
|
|
|
Attributes
|
|
----------
|
|
configuration : Configuration
|
|
Defines the basic configuration for the game
|
|
entities : MutableSet[Entity]
|
|
A set of all the entities on the current map, including the Hero
|
|
hero : Hero
|
|
The hero, the Entity controlled by the player
|
|
map : Map
|
|
A map of the current level
|
|
rng : tcod.random.Random
|
|
A random number generator
|
|
'''
|
|
|
|
def __init__(self, configuration: Configuration):
|
|
self.configuration = configuration
|
|
|
|
self.rng = tcod.random.Random()
|
|
self.map = Map(configuration.map_size)
|
|
self.hero = Hero(position=self.map.generator.rooms[0].center)
|
|
|
|
self.event_handler: 'EventHandler' = MainGameEventHandler(self)
|
|
|
|
self.entities: MutableSet[Entity] = {self.hero}
|
|
for room in self.map.rooms:
|
|
should_spawn_monster_chance = random.random()
|
|
if should_spawn_monster_chance < 0.4:
|
|
continue
|
|
|
|
floor = list(room.walkable_tiles)
|
|
for _ in range(2):
|
|
while True:
|
|
random_start_position = random.choice(floor)
|
|
if not any(ent.position == random_start_position for ent in self.entities):
|
|
break
|
|
|
|
spawn_monster_chance = random.random()
|
|
if spawn_monster_chance > 0.8:
|
|
monster = Monster(monsters.Troll, ai_class=HostileEnemy, position=random_start_position)
|
|
else:
|
|
monster = Monster(monsters.Orc, ai_class=HostileEnemy, position=random_start_position)
|
|
|
|
log.ENGINE.info('Spawning %s', monster)
|
|
self.entities.add(monster)
|
|
|
|
self.update_field_of_view()
|
|
|
|
def print_to_console(self, console):
|
|
'''Print the whole game to the given console.'''
|
|
self.map.print_to_console(console)
|
|
|
|
hp, max_hp = self.hero.fighter.hit_points, self.hero.fighter.maximum_hit_points
|
|
console.print(x=1, y=47, string=f'HP: {hp}/{max_hp}')
|
|
|
|
for ent in sorted(self.entities, key=lambda e: e.render_order.value):
|
|
# Only print entities that are in the field of view
|
|
if not self.map.visible[tuple(ent.position)]:
|
|
continue
|
|
ent.print_to_console(console)
|
|
|
|
def run_event_loop(self, context: tcod.context.Context, console: tcod.Console) -> NoReturn:
|
|
'''Run the event loop forever. This method never returns.'''
|
|
while True:
|
|
console.clear()
|
|
self.print_to_console(console)
|
|
context.present(console)
|
|
|
|
self.event_handler.wait_for_events()
|
|
|
|
def update_field_of_view(self) -> None:
|
|
'''Compute visible area of the map based on the player's position and point of view.'''
|
|
# FIXME: Move this to the Map class
|
|
self.map.visible[:] = tcod.map.compute_fov(
|
|
self.map.tiles['transparent'],
|
|
tuple(self.hero.position),
|
|
radius=8)
|
|
|
|
# Visible tiles should be added to the explored list
|
|
self.map.explored |= self.map.visible
|