mima-engine 0.4.0__py3-none-any.whl

mima/integrated/layered_map.py

@@ -0,0 +1,351 @@
+import math
+
+from pygame import Vector2
+from typing_extensions import Generic, Protocol
+
+from mima.integrated.entity import Entity, Nature, TEntity
+from mima.layered.shape import ShapeCollection
+from mima.standalone.geometry import Rect, shape_from_str
+from mima.standalone.spatial import SpatialGrid
+from mima.standalone.tiled_map import TiledObject, TiledTile, TiledTilemap, vfloor
+from mima.standalone.transformed_view import TileTransformedView
+
+VOFF = Vector2(0.1, 0.1)
+
+
+class Drawable(Protocol):
+    def draw(self, ttv: TileTransformedView, cache: bool = False) -> None: ...
+
+    def get_pos(self) -> Vector2: ...
+
+
+class Renderable:
+    def __init__(self, drawable: Drawable, layer: int, elevation: int) -> None:
+        self.drawable = drawable
+        self.layer = layer
+        self.elevation = elevation
+
+    def draw(self, ttv: TileTransformedView, cache: bool = False) -> None:
+        self.drawable.draw(ttv, cache)
+
+    def get_bottom(self) -> float:
+        return self.drawable.get_pos().y
+
+
+class ObjectLoader(Generic[TEntity]):
+    def load_objects(self, obj: TiledObject) -> list[tuple[TEntity, int]]: ...
+
+
+class LayeredMap(Generic[TEntity]):
+    def __init__(
+        self, tilemap: TiledTilemap, loader: ObjectLoader[TEntity] | None = None
+    ) -> None:
+        self._tilemap: TiledTilemap = tilemap
+        self._world_size: Vector2 = self._tilemap.world_size
+        self._cell_size: int = 8
+        self._map_objects: list[tuple[TEntity, int]] = []
+
+        self._background_layer: SpatialGrid[TEntity] = SpatialGrid[TEntity](
+            self._world_size, self._cell_size
+        )
+        self._collision_layer: SpatialGrid[TEntity] = SpatialGrid[TEntity](
+            self._world_size, self._cell_size
+        )
+        self._foreground_layer: SpatialGrid[TEntity] = SpatialGrid[TEntity](
+            self._world_size, self._cell_size
+        )
+        self._ui_layer: list[TEntity] = []
+        self._large_objects: list[TEntity] = []
+
+        self._loader: ObjectLoader | None = loader
+
+        self._visible_objects: set[TEntity] = set()
+        self._collisions: set[frozenset[TEntity]] = set()
+        self._prev_interactions: set[tuple[TEntity, TEntity]] = set()
+        self._curr_interactions: set[tuple[TEntity, TEntity]] = set()
+
+        self._tilemap.prerender_layers()
+        self.draw_grid: bool = False
+
+    def start_new_frame(self) -> None:
+        for grid in [
+            self._background_layer,
+            self._collision_layer,
+            self._foreground_layer,
+        ]:
+            objects = grid.get_all_objects()
+            redundants = [obj for obj in objects if obj.is_redundant]
+
+            for obj in redundants:
+                # TODO: query quests
+                obj.on_death()
+                grid.remove(obj)
+
+        self._tilemap.start_new_frame()
+
+    def update_global(self, elapsed_time: float) -> bool:
+        self._tilemap.update(elapsed_time)
+        it = [
+            (self._background_layer, self._background_layer.get_all_objects()),
+            (self._collision_layer, self._collision_layer.get_all_objects()),
+            (self._foreground_layer, self._foreground_layer.get_all_objects()),
+        ]
+        for grid, objects in it:
+            for obj in objects:
+                _update_object_global(elapsed_time, obj, grid)
+
+        for obj in self._ui_layer:
+            obj.update_global(elapsed_time)
+        return False
+
+    def update_visible(self, elapsed_time: float, ttv: TileTransformedView) -> bool:
+        self.view = Rect(
+            ttv.get_tl_tile() - Vector2(0.5, 0.5),
+            ttv.get_br_tile() - ttv.get_tl_tile() + Vector2(1.5, 1.5),
+        )
+
+        self._curr_interactions.clear()
+        self._collisions.clear()
+
+        visible_objects = self._collision_layer.get_objects_in_region(
+            self.view.pos, self.view.size
+        )
+
+        for obj in visible_objects:
+            obj.update_visible(elapsed_time, ttv)
+
+            if not obj.is_collider:
+                continue
+
+            elevation = math.floor(obj.elevation)
+            hitbox = obj.get_hitbox()
+            tl = vfloor(hitbox.get_tl_pos() - VOFF)
+            br = vfloor(hitbox.get_br_pos() + VOFF)
+            if obj.collides_with_map:
+                # Collision with map
+                for y in range(int(tl.y), int(br.y) + 1):
+                    for x in range(int(tl.x), int(br.x) + 1):
+                        tiles = self._tilemap.get_tiles(x, y, elevation)
+                        new_pos = collide_with_tiles(hitbox, tiles, Vector2(x, y))
+                        self.relocate_object(self._collision_layer, obj, new_pos)
+
+            tl = hitbox.get_tl_pos() - (VOFF * 2)
+            br = hitbox.get_br_pos() + (VOFF * 2)
+            obj_view = Rect(tl, br - tl)
+            close_objects = self._collision_layer.get_objects_in_region(
+                obj_view.pos, obj_view.size
+            )
+
+            # Collision with other objects
+            for other in close_objects:
+                if obj == other:
+                    continue
+                # TODO: implement overlaps/resolve_collision for hitboxes
+                if obj.get_hitbox().overlaps(other.get_hitbox().bounding_box):
+                    self._collisions.add(frozenset({obj, other}))
+
+        for obj1, obj2 in self._collisions:
+            collider = obj1
+            target = obj2
+
+            move_both = obj1.is_collider and obj2.is_collider
+            if not move_both and obj2.is_collider:
+                collider, target = obj2, obj1
+            elif move_both and id(obj1) > id(obj2):
+                collider, target = obj2, obj1
+
+            if obj1.collides_with_dyn and obj2.collides_with_dyn:
+                new_pos1, new_pos2 = collider.get_hitbox().resolve_collision(
+                    target.get_hitbox().bounding_box, move_both
+                )
+                self.relocate_object(self._collision_layer, collider, new_pos1)
+                self.relocate_object(self._collision_layer, target, new_pos2)
+
+            self._curr_interactions.add((obj1, obj2))
+            self._curr_interactions.add((obj2, obj1))
+
+        entered = self._curr_interactions - self._prev_interactions
+        stayed = self._curr_interactions & self._prev_interactions
+        exited = self._prev_interactions - self._curr_interactions
+        for collider, target in entered:
+            target.on_interaction(collider, Nature.ENTER)
+            # elif obj.is_player:  # implicitly: obj.collides_with_dyn==True
+            #     # Check quests (somehow; they are not available here)
+            #     # self.on_interaction(other, Nature.WALK)
+        for collider, target in stayed:
+            target.on_interaction(collider, Nature.WALK)
+        for collider, target in exited:
+            target.on_interaction(collider, Nature.EXIT)
+        self._prev_interactions = self._curr_interactions.copy()
+        return False
+
+    def draw(self, ttv: TileTransformedView) -> None:
+        renderables: list[Renderable] = []
+
+        for layer in self._tilemap.get_rendered_layers():
+            renderables.append(Renderable(layer, layer.layer, layer.elevation))
+
+        for layer, objects in enumerate(
+            [
+                self._background_layer.get_objects_in_region(
+                    self.view.pos, self.view.size
+                ),
+                self._collision_layer.get_objects_in_region(
+                    self.view.pos, self.view.size
+                ),
+                self._foreground_layer.get_objects_in_region(
+                    self.view.pos, self.view.size
+                ),
+            ]
+        ):
+            for obj in objects:
+                renderables.append(Renderable(obj, layer, math.floor(obj.elevation)))
+
+        draw_sorted(renderables, ttv)
+
+        for obj in self._ui_layer:
+            obj.draw(ttv)
+
+        if self.draw_grid:
+            # cells = self._collision_layer.get_cells_in_region(
+            #     self.view.pos, self.view.size
+            # )
+            # visible_cells = len(cells)
+            world_size = self._collision_layer._world_size  # type: ignore[reportPrivateUsage]
+            cell_size = self._collision_layer._cell_size  # type: ignore[reportPrivateUsage]
+            for i in range(0, int(world_size.x), cell_size):
+                ttv.draw_line(Vector2(i, 0), Vector2(i, world_size.y), (0, 255, 255))
+            for i in range(0, int(world_size.y), cell_size):
+                ttv.draw_line(Vector2(0, i), Vector2(world_size.x, i))
+
+        return
+
+    def relocate_object(
+        self, grid: SpatialGrid[TEntity], obj: TEntity, new_pos: Vector2
+    ) -> None:
+        obj.old_pos = obj.get_pos()
+        obj.set_pos(new_pos)
+        grid.relocate(obj, obj.old_pos, new_pos)
+
+    def add_to_layer(self, obj: TEntity, layer: int = 1) -> None:
+        if layer == 0:
+            self._background_layer.insert(
+                obj, obj.get_pos(), obj.get_hitbox().get_bounding_size()
+            )
+        elif layer == 2:
+            self._foreground_layer.insert(
+                obj, obj.get_pos(), obj.get_hitbox().get_bounding_size()
+            )
+        elif layer == 3:
+            self._ui_layer.append(obj)
+        else:
+            self._collision_layer.insert(
+                obj, obj.get_pos(), obj.get_hitbox().get_bounding_size()
+            )
+
+    def remove_from_layer(self, obj: TEntity, layer: int = 1) -> None:
+        if layer == 0:
+            self._background_layer.remove(obj)
+        elif layer == 2:
+            self._foreground_layer.remove(obj)
+        elif layer == 3 and obj in self._ui_layer:
+            self._ui_layer.remove(obj)
+        else:
+            self._collision_layer.remove(obj)
+
+    def populate_dynamics(self) -> None:
+        self._background_layer.clear()
+        self._collision_layer.clear()
+        self._foreground_layer.clear()
+
+        if self._map_objects:
+            for dyn, layer in self._map_objects:
+                dyn.on_interaction(dyn, Nature.RESUME)
+                self.add_to_layer(dyn, layer)
+        elif self._loader is not None:
+            for obj in self._tilemap.get_objects():
+                dyns = self._loader.load_objects(obj)
+                for dyn, layer in dyns:
+                    self.add_to_layer(dyn, layer)
+                    self._map_objects.append((dyn, layer))
+
+    def is_tile_free(
+        self, pos: Vector2, size: Vector2 | None = None, elevation: int = 0
+    ) -> bool:
+        size = Vector2(1, 1) if size is None else size
+
+        tiles = self._tilemap.get_tiles_in_area(pos, size, elevation)
+
+        free = True
+        for tile in tiles:
+            if tile.get_collision_boxes():
+                return False
+
+        # TODO: Check existing objects
+        return free
+
+    @property
+    def name(self) -> str:
+        return self._tilemap.name
+
+    @property
+    def tl(self) -> Vector2:
+        return self._tilemap.tl
+
+    @property
+    def br(self) -> Vector2:
+        return self._tilemap.br
+
+    @property
+    def n_objects(self) -> int:
+        return (
+            self._background_layer.n_objects
+            + self._collision_layer.n_objects
+            + self._foreground_layer.n_objects
+            + len(self._ui_layer)
+        )
+
+    def set_loader(self, loader: ObjectLoader[TEntity]) -> None:
+        self._loader = loader
+
+
+def _update_object_global(
+    elapsed_time: float, obj: TEntity, grid: SpatialGrid[TEntity]
+) -> None:
+    obj.update_global(elapsed_time)
+    pos = obj.get_pos()
+    obj.old_pos = pos
+    new_pos = pos + obj.vel * obj.speed * elapsed_time
+    obj.set_pos(new_pos)
+    grid.relocate(obj, pos, new_pos)
+
+
+def collide_with_tiles(
+    obj: ShapeCollection, tiles: list[TiledTile], tile_offset: Vector2
+) -> Vector2:
+    obj_origin = obj.pos
+
+    for tile in tiles:
+        hitboxes = tile.get_collision_boxes()
+
+        if not hitboxes:
+            continue
+
+        for hitbox in hitboxes:
+            shape = shape_from_str(
+                hitbox.shape, hitbox.pos + tile_offset, hitbox.size, hitbox.radius
+            )
+
+            if obj.overlaps(shape):
+                res = obj.resolve_collision(shape)
+                obj.pos = res[0]
+    new_pos = obj.pos
+    obj.pos = obj_origin
+    return new_pos
+
+
+def draw_sorted(renderables: list[Renderable], ttv: TileTransformedView) -> None:
+    renderables.sort(key=lambda r: (r.layer, r.elevation, r.get_bottom()))
+
+    for r in renderables:
+        r.draw(ttv, cache=True)

mima/integrated/sprite.py

@@ -0,0 +1,156 @@
+from enum import Enum
+
+from pygame import Vector2
+from typing_extensions import Tuple
+
+from mima.layered.shaped_sprite import SpriteWithShape
+from mima.standalone.tiled_map import TiledTileset
+
+
+class GraphicState(Enum):
+    STANDING = 0
+    WALKING = 1
+    ATTACKING = 2
+    DAMAGED = 3
+    CELEBRATING = 4
+    DEAD = 5
+    DEFEATED = 6
+    PUSHING = 7
+    OPEN = 8
+    CLOSED = 9
+    LOCKED = 10
+    OFF = 11
+    ON = 12
+    ICON = 13
+
+
+class Direction4(Enum):
+    SOUTH = 0
+    WEST = 1
+    NORTH = 2
+    EAST = 3
+
+
+Direction = Direction4
+
+
+class Direction8(Enum):
+    SOUTH = 0
+    SOUTHWEST = 1
+    WEST = 2
+    NORTH_WEST = 3
+    NORTH = 4
+    NORTH_EAST = 5
+    EAST = 6
+    SOUTH_EAST = 7
+
+
+def sprite_from_tileset(
+    tileset: TiledTileset, sprite_name: str
+) -> SpriteWithShape[GraphicState, Direction]:
+    sprite = SpriteWithShape[GraphicState, Direction]()
+
+    for tile in tileset.tiles.values():
+        if tile.get("sprite_name", "") != sprite_name:
+            continue
+
+        gs = GraphicState[tile.get("graphic_state", "standing").upper()]
+        d = Direction[tile.get("facing_direction", "south").upper()]
+        if tile.animated:
+            for frame in tile.frames:
+                sprite.add_frame(gs, d, frame.as_dict())
+        else:
+            sprite.add_frame(gs, d, tile.get_frame().as_dict())
+
+    return sprite
+
+
+def sprite_from_tileset_gid(
+    tileset: TiledTileset, gid: int
+) -> SpriteWithShape[GraphicState, Direction]:
+    sprite = SpriteWithShape[GraphicState, Direction]()
+
+    tile = tileset.tiles[gid]
+    gs = GraphicState[tile.get("graphic_state", "standing").upper()]
+    d = Direction[tile.get("facing_direction", "south").upper()]
+
+    if tile.animated:
+        for frame in tile.frames:
+            sprite.add_frame(gs, d, frame.as_dict())
+    else:
+        sprite.add_frame(gs, d, tile.get_frame().as_dict())
+
+    return sprite
+
+
+def vel_to_dir(v: Vector2):
+    direction = None
+    if abs(v.x) >= abs(v.y):
+        if v.x > 0:
+            direction = Direction.EAST
+        elif v.x < 0:
+            direction = Direction.WEST
+        else:
+            # TODO: Check for up and down
+            pass
+    elif abs(v.x) < abs(v.y):
+        if v.y > 0:
+            direction = Direction.SOUTH
+        elif v.y < 0:
+            direction = Direction.NORTH
+        else:
+            # TODO: Check for left and right
+            pass
+    return direction
+
+
+def dir_to_vel(direction: Direction) -> Tuple[int, int]:
+    vx = vy = 0
+
+    if direction == Direction.SOUTH:
+        vy = 1
+    elif direction == Direction.EAST:
+        vx = 1
+    elif direction == Direction.NORTH:
+        vy = -1
+    elif direction == Direction.WEST:
+        vx = -1
+    return vx, vy
+
+
+class Anchor(Enum):
+    TOP_LEFT = 0
+    TOP_RIGHT = 1
+    BOTTOM_LEFT = 2
+    BOTTOM_RIGHT = 3
+    CENTER = 4
+    TOP_CENTER = 5
+    RIGHT_CENTER = 6
+    BOTTOM_CENTER = 7
+    LEFT_CENTER = 8
+
+
+def anchor_offset(anchor: Anchor) -> Vector2:
+    if anchor == Anchor.TOP_RIGHT:
+        return Vector2(-1, 0)
+    elif anchor == Anchor.BOTTOM_LEFT:
+        return Vector2(0, -1)
+    elif anchor == Anchor.BOTTOM_RIGHT:
+        return Vector2(-1, -1)
+    elif anchor == Anchor.CENTER:
+        return Vector2(-0.5, -0.5)
+    elif anchor == Anchor.TOP_CENTER:
+        return Vector2(-0.5, 0)
+    elif anchor == Anchor.RIGHT_CENTER:
+        return Vector2(-1, -0.5)
+    elif anchor == Anchor.BOTTOM_CENTER:
+        return Vector2(-0.5, -1.0)
+    elif anchor == Anchor.LEFT_CENTER:
+        return Vector2(0, -0.5)
+    else:
+        return Vector2()
+
+
+class Until(Enum):
+    UNLOCK = 0
+    NEXT_UPDATE = 1

mima/layered/assets.py

@@ -0,0 +1,56 @@
+import csv
+import logging
+from pathlib import Path
+
+from typing_extensions import TypeAlias
+
+from mima.standalone.tiled_map import MapManager
+
+CSVContent: TypeAlias = list[dict[str, str]]
+LOG = logging.getLogger(__name__)
+
+
+class AssetManager(MapManager):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._csvs: dict[str, CSVContent] = {}
+
+    def _load_file(self, fp: Path, skip_invalid: bool = False) -> None:
+        fp = fp.resolve()
+        if str(fp) in self._loaded_paths:
+            return
+
+        _, suf = fp.parts[-1].rsplit(".")
+
+        if suf.lower() == "png":
+            self._load_image(fp)
+        elif suf.lower() == "csv":
+            self._load_csv(fp)
+        else:
+            super()._load_file(fp, skip_invalid)
+
+    def _load_csv(self, path: Path) -> str:
+        name = Path(path).parts[-1].rsplit(".", 1)[0]
+        if name in self._csvs:
+            return name
+
+        with path.open("r") as csv_file:
+            reader = csv.DictReader(csv_file, delimiter=",")
+            self._csvs[name] = [r for r in reader]
+
+        self._loaded_paths[str(path)] = name
+
+        return name
+
+    def get_csv(self, name: str | Path) -> CSVContent:
+        name = str(name)
+        if name in self._csvs:
+            return self._csvs[name]
+        if name in self._loaded_paths:
+            return self._csvs[self._loaded_paths[name]]
+
+        LOG.info("CSV '%s' not found. Attempting to read from disk ...", name)
+        self._load_csv(Path(name))
+
+        return self._csvs[self._loaded_paths[name]]