Reworked the code to work better after tutorial stuff
This commit is contained in:
parent
0dcf3bf975
commit
721fc3b41e
@ -4,8 +4,12 @@
|
||||
|
||||
The "water meter" is always visible, and ticks down each time you take an action. When it hits zero, you die.
|
||||
|
||||
This will probably see some iteration.
|
||||
|
||||
## Link
|
||||
|
||||
https://python-tcod.readthedocs.io/en/latest/
|
||||
|
||||
I'm working from this:
|
||||
|
||||
https://rogueliketutorials.com/tutorials/tcod/v2/part-4/
|
||||
|
||||
@ -1,37 +1,26 @@
|
||||
from __future__ import annotations
|
||||
from engine import Engine
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
from entity import Entity
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from engine import Engine
|
||||
from entity import Entity
|
||||
|
||||
class Action: #lawsuit?
|
||||
def perform(self, engine: Engine, entity: Entity) -> None:
|
||||
"Oh look, the visitor pattern!"
|
||||
class Action:
|
||||
def apply(self, engine: Engine) -> None:
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
class EscapeAction(Action):
|
||||
def perform(self, engine: Engine, entity: Entity) -> None:
|
||||
class QuitAction(Action):
|
||||
def apply(self, engine: Engine) -> None:
|
||||
raise SystemExit()
|
||||
|
||||
|
||||
class MovementAction(Action):
|
||||
def __init__(self, dx: int, dy: int):
|
||||
class MoveAction(Action):
|
||||
def __init__(self, entity: Entity, xdir: int, ydir: int):
|
||||
super().__init__()
|
||||
self.entity = entity
|
||||
self.xdir = xdir
|
||||
self.ydir = ydir
|
||||
|
||||
self.dx = dx
|
||||
self.dy = dy
|
||||
def apply(self, engine: Engine) -> None:
|
||||
x = self.entity.x + self.xdir
|
||||
y = self.entity.y + self.ydir
|
||||
|
||||
def perform(self, engine: Engine, entity: Entity) -> None:
|
||||
dest_x = entity.x + self.dx
|
||||
dest_y = entity.y + self.dy
|
||||
|
||||
if not engine.game_map.in_bounds(dest_x, dest_y):
|
||||
return
|
||||
if not engine.game_map.tiles["walkable"][dest_x, dest_y]:
|
||||
return
|
||||
|
||||
entity.set_pos(dest_x, dest_y)
|
||||
#TODO: bounds checks
|
||||
|
||||
self.entity.set_pos(x, y)
|
||||
|
||||
@ -1,21 +1,17 @@
|
||||
from typing import Set, Iterable, Any
|
||||
from typing import Any, Iterable
|
||||
|
||||
from tcod.context import Context
|
||||
from tcod.console import Console
|
||||
|
||||
from event_handler import EventHandler
|
||||
from actions import EscapeAction, MovementAction
|
||||
|
||||
from entity import Entity
|
||||
from game_map import GameMap
|
||||
|
||||
class Engine:
|
||||
def __init__(self, entities: Set[Entity], event_handler: EventHandler, game_map: GameMap, player: Entity):
|
||||
self.entities = entities
|
||||
self.event_handler = event_handler
|
||||
self.game_map = game_map
|
||||
self.player = player
|
||||
|
||||
def __init__(self):
|
||||
from event_handler import EventHandler
|
||||
self.event_handler = EventHandler(self)
|
||||
|
||||
self.player = Entity(0, 0, "@", (255, 255, 255))
|
||||
|
||||
def handle_events(self, events: Iterable[Any]) -> None:
|
||||
for event in events:
|
||||
action = self.event_handler.dispatch(event)
|
||||
@ -23,13 +19,17 @@ class Engine:
|
||||
if action is None:
|
||||
continue
|
||||
|
||||
action.perform(self, self.player)
|
||||
action.apply(Engine)
|
||||
|
||||
def render(self, console: Console, context: Context) -> None:
|
||||
self.game_map.render(console)
|
||||
def render(self, context: Context, console: Console) -> None:
|
||||
#TODO: render map
|
||||
|
||||
for entity in self.entities:
|
||||
console.print(entity.x, entity.y, entity.char, fg=entity.color)
|
||||
|
||||
#TODO: render entities
|
||||
# for entity in self.entities:
|
||||
# console.print(entity.x, entity.y, entity.char, fg=entity.color)
|
||||
|
||||
console.print(self.player.x, self.player.y, self.player.char, fg=self.player.color)
|
||||
|
||||
#send to the screen
|
||||
context.present(console)
|
||||
console.clear()
|
||||
|
||||
@ -1,14 +1,12 @@
|
||||
from typing import Tuple
|
||||
|
||||
|
||||
class Entity:
|
||||
def __init__(self, x: int, y: int, char: str, color: Tuple[int, int, int]):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.char = char
|
||||
self.color = color
|
||||
def __init__(self, x: int, y: int, char: str, color: Tuple[int, int, int]):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.char = char
|
||||
self.color = color
|
||||
|
||||
def set_pos(self, dx: int, dy: int) -> None:
|
||||
# Move the entity by a given amount
|
||||
self.x = dx
|
||||
self.y = dy
|
||||
def set_pos(self, x: int, y: int) -> None:
|
||||
self.x = x
|
||||
self.y = y
|
||||
|
||||
@ -1,31 +1,34 @@
|
||||
from typing import Optional
|
||||
|
||||
import tcod.event
|
||||
|
||||
from actions import Action, EscapeAction, MovementAction
|
||||
import tcod
|
||||
|
||||
from actions import Action, QuitAction, MoveAction
|
||||
from engine import Engine
|
||||
|
||||
class EventHandler(tcod.event.EventDispatch[Action]):
|
||||
def ev_quit(self, event: tcod.event.Quit) -> Optional[Action]:
|
||||
raise SystemExit()
|
||||
def __init__(self, engine: Engine):
|
||||
super().__init__()
|
||||
self.engine = engine
|
||||
|
||||
def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[Action]:
|
||||
action: Optional[Action] = None
|
||||
def ev_quit(self, event: tcod.event.Quit) -> Optional[Action]:
|
||||
return QuitAction()
|
||||
|
||||
key = event.sym
|
||||
def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[Action]:
|
||||
key = event.sym #SDL stuff, neat.
|
||||
|
||||
# parse input
|
||||
if key == tcod.event.KeySym.UP:
|
||||
action = MovementAction(dx=0, dy=-1)
|
||||
elif key == tcod.event.KeySym.DOWN:
|
||||
action = MovementAction(dx=0, dy=1)
|
||||
elif key == tcod.event.KeySym.LEFT:
|
||||
action = MovementAction(dx=-1, dy=0)
|
||||
elif key == tcod.event.KeySym.RIGHT:
|
||||
action = MovementAction(dx=1, dy=0)
|
||||
#parse input
|
||||
match key:
|
||||
case tcod.event.KeySym.ESCAPE:
|
||||
return QuitAction()
|
||||
|
||||
elif key == tcod.event.KeySym.ESCAPE:
|
||||
action = EscapeAction()
|
||||
case tcod.event.KeySym.UP:
|
||||
return MoveAction(self.engine.player, xdir = 0, ydir = -1)
|
||||
case tcod.event.KeySym.DOWN:
|
||||
return MoveAction(self.engine.player, xdir = 0, ydir = 1)
|
||||
case tcod.event.KeySym.LEFT:
|
||||
return MoveAction(self.engine.player, xdir = -1, ydir = 0)
|
||||
case tcod.event.KeySym.RIGHT:
|
||||
return MoveAction(self.engine.player, xdir = 1, ydir = 0)
|
||||
|
||||
# No valid key was pressed
|
||||
return action
|
||||
case _:
|
||||
return None
|
||||
@ -1,18 +0,0 @@
|
||||
import numpy as np
|
||||
from tcod.console import Console
|
||||
|
||||
import tile_types
|
||||
|
||||
|
||||
class GameMap:
|
||||
def __init__(self, width: int, height: int):
|
||||
self.width = width
|
||||
self.height = height
|
||||
self.tiles = np.full((width, height), fill_value=tile_types.wall, order="F")
|
||||
|
||||
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 render(self, console: Console) -> None:
|
||||
console.rgb[0:self.width, 0:self.height] = self.tiles["dark"]
|
||||
@ -2,49 +2,37 @@
|
||||
import tcod
|
||||
|
||||
from engine import Engine
|
||||
from entity import Entity
|
||||
from procgen import generate_dungeon
|
||||
from event_handler import EventHandler
|
||||
|
||||
|
||||
def main() -> None:
|
||||
#Initial values
|
||||
screen_width = 80
|
||||
screen_height = 50
|
||||
|
||||
map_width = 80
|
||||
map_height = 45
|
||||
|
||||
room_size_max = 10
|
||||
room_size_min = 6
|
||||
room_count_max = 30
|
||||
|
||||
#assets
|
||||
tileset = tcod.tileset.load_tilesheet("assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD)
|
||||
|
||||
#entities
|
||||
player = Entity(screen_width // 2, screen_height // 2, "@", (255, 255, 255))
|
||||
shopkeeper = Entity(screen_width // 2 - 5, screen_height // 2, "@", (255, 255, 0))
|
||||
entities = {player, shopkeeper}
|
||||
context = tcod.context.new(
|
||||
columns = 40,
|
||||
rows = 20,
|
||||
tileset = tileset,
|
||||
title = "Stepwise Roguelike",
|
||||
vsync = True
|
||||
)
|
||||
|
||||
game_map = generate_dungeon(room_count_max=room_count_max, room_size_min=room_size_min, room_size_max=room_size_max, map_width=map_width, map_height=map_height, player=player)
|
||||
w, h = context.recommended_console_size(min_columns=10, min_rows=10)
|
||||
|
||||
event_handler = EventHandler()
|
||||
print(w, h)
|
||||
|
||||
engine = Engine(entities, event_handler, game_map, player)
|
||||
console = tcod.console.Console(
|
||||
width = w,
|
||||
height = h,
|
||||
order = "F"
|
||||
)
|
||||
|
||||
with tcod.context.new_terminal(
|
||||
screen_width,
|
||||
screen_height,
|
||||
tileset=tileset,
|
||||
title="Stepwise Tutorial",
|
||||
vsync=True,
|
||||
) as context:
|
||||
root_console = tcod.console.Console(screen_width, screen_height, order="F")
|
||||
while True:
|
||||
engine.render(console = root_console, context = context)
|
||||
events = tcod.event.wait()
|
||||
engine.handle_events(events)
|
||||
engine = Engine()
|
||||
|
||||
# game loop
|
||||
while True:
|
||||
engine.render(context, console)
|
||||
events = tcod.event.wait()
|
||||
engine.handle_events(events)
|
||||
|
||||
# this seems odd to me
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,81 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import random
|
||||
from typing import Iterator, List, Tuple, TYPE_CHECKING
|
||||
|
||||
import tcod
|
||||
|
||||
from game_map import GameMap
|
||||
import tile_types
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from entity import Entity
|
||||
|
||||
class RectangularRoom:
|
||||
def __init__(self, x: int, y: int, width: int, height: int):
|
||||
self.x1 = x
|
||||
self.y1 = y
|
||||
self.x2 = x + width
|
||||
self.y2 = y + height
|
||||
|
||||
@property
|
||||
def center(self) -> Tuple[int, int]:
|
||||
center_x = (self.x1 + self.x2) // 2
|
||||
center_y = (self.y1 + self.y2) // 2
|
||||
|
||||
return center_x, center_y
|
||||
|
||||
@property
|
||||
def inner(self) -> Tuple[slice, slice]:
|
||||
return slice(self.x1 + 1, self.x2), slice(self.y1 + 1, self.y2)
|
||||
|
||||
def intersects(self, other: RectangularRoom) -> bool:
|
||||
return (
|
||||
self.x1 <= other.x2 and
|
||||
self.x2 >= other.x1 and
|
||||
self.y1 <= other.y2 and
|
||||
self.y2 >= other.y1
|
||||
)
|
||||
|
||||
def tunnel_between(start: Tuple[int, int], end: Tuple[int, int]) -> Iterator[Tuple[int, int]]:
|
||||
x1, y1 = start
|
||||
x2, y2 = end
|
||||
|
||||
if random.random() < 0.5:
|
||||
corner_x, corner_y = x2, y1
|
||||
else:
|
||||
corner_x, corner_y = x1, y2
|
||||
|
||||
for x, y in tcod.los.bresenham((x1, y1), (corner_x, corner_y)).tolist():
|
||||
yield x, y
|
||||
for x, y in tcod.los.bresenham((corner_x, corner_y), (x2, y2)).tolist():
|
||||
yield x, y
|
||||
|
||||
def generate_dungeon(room_count_max: int, room_size_min: int, room_size_max: int, map_width: int, map_height: int, player: Entity) -> GameMap:
|
||||
dungeon = GameMap(map_width, map_height)
|
||||
|
||||
rooms: List[RectangularRoom] = []
|
||||
|
||||
for r in range(room_count_max):
|
||||
room_width = random.randint(room_size_min, room_size_max)
|
||||
room_height = random.randint(room_size_min, room_size_max)
|
||||
|
||||
x = random.randint(0, dungeon.width - room_width - 1)
|
||||
y = random.randint(0, dungeon.height - room_height - 1)
|
||||
|
||||
new_room = RectangularRoom(x, y, room_width, room_height)
|
||||
|
||||
if any(new_room.intersects(other_room) for other_room in rooms):
|
||||
continue
|
||||
|
||||
dungeon.tiles[new_room.inner] = tile_types.floor
|
||||
|
||||
if len(rooms) == 0:
|
||||
player.x, player.y = new_room.center
|
||||
else:
|
||||
for x, y in tunnel_between(rooms[-1].center, new_room.center):
|
||||
dungeon.tiles[x, y] = tile_types.floor
|
||||
|
||||
rooms.append(new_room)
|
||||
|
||||
return dungeon
|
||||
@ -1,29 +0,0 @@
|
||||
from typing import Tuple
|
||||
|
||||
import numpy as np #libtcod is built on this
|
||||
|
||||
#data types
|
||||
graphic_dt = np.dtype(
|
||||
[
|
||||
("ch", np.int32),
|
||||
("fg", "3B"),
|
||||
("bg", "3B")
|
||||
]
|
||||
)
|
||||
|
||||
tile_dt = np.dtype(
|
||||
[
|
||||
("walkable", np.bool), # True if this tile can be walked over.
|
||||
("transparent", np.bool), # True if this tile doesn't block FOV.
|
||||
("dark", graphic_dt), # Graphics for when this tile is not in FOV.
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def new_tile(*, walkable: int, transparent: int, dark: Tuple[int, Tuple[int, int, int], Tuple[int, int, int]], ) -> np.ndarray:
|
||||
"""Helper function for defining individual tile types """
|
||||
return np.array((walkable, transparent, dark), dtype=tile_dt)
|
||||
|
||||
|
||||
floor = new_tile(walkable=True, transparent=True, dark=(ord(" "), (255, 255, 255), (50, 50, 150)))
|
||||
wall = new_tile(walkable=False, transparent=False, dark=(ord(" "), (255, 255, 255), (0, 0, 100)))
|
||||
Loading…
x
Reference in New Issue
Block a user