Eryn Wells
4002b64640
Refactor MovePlayerAction into a few different Action subclasses. Move direction
to a parent MoveAction, and create three new subclasses of MoveAction:
- BumpAction: perform the test that an action can be performed in the given direction
- WalkAction, take a step in the given direction
- MeleeAction, attack another Entity in the given direction
Add an ActionResult class that communicates the result of performing an Action.
- ActionResult.succeeded indicates whether the action succeeded.
- ActionResult.done indicates if the action is fully complete or requires followup.
- ActionResult.alternate specifies the follow-up action to perform.
Convert all the key handling actions to BumpActions.
In the Engine's event handler method, loop until an action is completed,
performing specified alternate actions until the result object indicates the
action is done.
127 lines
No EOL
3.5 KiB
Python
127 lines
No EOL
3.5 KiB
Python
#!/usr/bin/env python3
|
|
# Eryn Wells <eryn@erynwells.me>
|
|
|
|
from dataclasses import dataclass
|
|
from typing import Any, Iterator, overload
|
|
|
|
@dataclass(frozen=True)
|
|
class Point:
|
|
x: int = 0
|
|
y: int = 0
|
|
|
|
@overload
|
|
def __add__(self, other: 'Vector') -> 'Point':
|
|
...
|
|
|
|
def __add__(self, other: Any) -> 'Point':
|
|
if not isinstance(other, Vector):
|
|
raise TypeError('Only Vector can be added to a Point')
|
|
return Point(self.x + other.dx, self.y + other.dy)
|
|
|
|
def __iter__(self):
|
|
yield self.x
|
|
yield self.y
|
|
|
|
def __str__(self):
|
|
return f'(x:{self.x}, y:{self.y})'
|
|
|
|
@dataclass(frozen=True)
|
|
class Vector:
|
|
dx: int = 0
|
|
dy: int = 0
|
|
|
|
def __iter__(self):
|
|
yield self.dx
|
|
yield self.dy
|
|
|
|
def __str__(self):
|
|
return f'(δx:{self.dx}, δy:{self.dy})'
|
|
|
|
class Direction:
|
|
North = Vector(0, -1)
|
|
NorthEast = Vector(1, -1)
|
|
East = Vector(1, 0)
|
|
SouthEast = Vector(1, 1)
|
|
South = Vector(0, 1)
|
|
SouthWest = Vector(-1, 1)
|
|
West = Vector(-1, 0)
|
|
NorthWest = Vector(-1, -1)
|
|
|
|
@classmethod
|
|
def all(cls) -> Iterator['Direction']:
|
|
'''Iterate through all directions, starting with North and proceeding clockwise'''
|
|
yield Direction.North
|
|
yield Direction.NorthEast
|
|
yield Direction.East
|
|
yield Direction.SouthEast
|
|
yield Direction.South
|
|
yield Direction.SouthWest
|
|
yield Direction.West
|
|
yield Direction.NorthWest
|
|
|
|
@dataclass(frozen=True)
|
|
class Size:
|
|
width: int = 0
|
|
height: int = 0
|
|
|
|
def __iter__(self):
|
|
yield self.width
|
|
yield self.height
|
|
|
|
def __str__(self):
|
|
return f'(w:{self.width}, h:{self.height})'
|
|
|
|
@dataclass(frozen=True)
|
|
class Rect:
|
|
origin: Point
|
|
size: Size
|
|
|
|
@property
|
|
def min_x(self) -> int:
|
|
'''Minimum x-value that is still within the bounds of this rectangle. This is the origin's x-value.'''
|
|
return self.origin.x
|
|
|
|
@property
|
|
def min_y(self) -> int:
|
|
'''Minimum y-value that is still within the bounds of this rectangle. This is the origin's y-value.'''
|
|
return self.origin.y
|
|
|
|
@property
|
|
def mid_x(self) -> int:
|
|
'''The x-value of the center point of this rectangle.'''
|
|
return int(self.origin.x + self.size.width / 2)
|
|
|
|
@property
|
|
def mid_y(self) -> int:
|
|
'''The y-value of the center point of this rectangle.'''
|
|
return int(self.origin.y + self.size.height / 2)
|
|
|
|
@property
|
|
def max_x(self) -> int:
|
|
'''Maximum x-value that is still within the bounds of this rectangle.'''
|
|
return self.origin.x + self.size.width - 1
|
|
|
|
@property
|
|
def max_y(self) -> int:
|
|
'''Maximum y-value that is still within the bounds of this rectangle.'''
|
|
return self.origin.y + self.size.height - 1
|
|
|
|
@property
|
|
def midpoint(self) -> Point:
|
|
return Point(self.mid_x, self.mid_y)
|
|
|
|
def inset_rect(self, top: int = 0, right: int = 0, bottom: int = 0, left: int = 0) -> 'Rect':
|
|
'''
|
|
Return a new Rect inset from this rect by the specified values. Arguments are listed in clockwise order around
|
|
the permeter. This method doesn't do any validation or transformation of the returned Rect to make sure it's
|
|
valid.
|
|
'''
|
|
return Rect(Point(self.origin.x + left, self.origin.y + top),
|
|
Size(self.size.width - right - left, self.size.height - top - bottom))
|
|
|
|
def __iter__(self):
|
|
yield tuple(self.origin)
|
|
yield tuple(self.size)
|
|
|
|
def __str__(self):
|
|
return f'[{self.origin}, {self.size}]' |