Ninja-Jump-and-run/scripts/tilemap.py

import json
import pygame
from scripts.models import Tile

AUTOTILE_MAP: dict[tuple[tuple[int, int], ...], int] = {
    tuple(sorted([(1, 0), (0, 1)])): 0,
    tuple(sorted([(1, 0), (0, 1), (-1, 0)])): 1,
    tuple(sorted([(-1, 0), (0, 1)])): 2,
    tuple(sorted([(-1, 0), (0, -1), (0, 1)])): 3,
    tuple(sorted([(-1, 0), (0, -1)])): 4,
    tuple(sorted([(-1, 0), (0, -1), (1, 0)])): 5,
    tuple(sorted([(1, 0), (0, -1)])): 6,
    tuple(sorted([(1, 0), (0, -1), (0, 1)])): 7,
    tuple(sorted([(1, 0), (-1, 0), (0, 1), (0, -1)])): 8,
}

NEIGHBOR_OFFSETS: list[tuple[int, int]] = [(-1, 0), (-1, -1), (0, -1), (1, -1), (1, 0), (0, 0), (-1, 1), (0, 1), (1, 1)]
PHYSICS_TILES: set[str] = {'grass', 'stone'}
AUTOTILE_TYPES: set[str] = {'grass', 'stone'}

class Tilemap:
    def __init__(self, game, tile_size: int = 16) -> None:
        self.game = game
        self.tile_size: int = tile_size
        self.tilemap: dict[str, Tile] = {}
        self.offgrid_tiles: list[Tile] = []
    
    def extract(self, id_pairs: list[tuple[str, int]], keep: bool = False) -> list[dict]:
        matches: list[dict] = []
        for tile in self.offgrid_tiles.copy():
            if (tile.type, tile.variant) in id_pairs:
                matches.append(tile.to_dict())
                if not keep:
                    self.offgrid_tiles.remove(tile)

        for loc in list(self.tilemap):
            tilemap_tile = self.tilemap[loc]
            if (tilemap_tile.type, tilemap_tile.variant) in id_pairs:
                end_match = tilemap_tile.to_dict()
                end_match["pos"] = [end_match['pos'][0] * self.tile_size, end_match['pos'][1] * self.tile_size]

                matches.append(end_match)

                if not keep:
                    del self.tilemap[loc]
        return matches

    def tiles_around(self, pos: tuple[float, float]) -> list[Tile]:
        tiles: list[Tile] = []
        tile_location: tuple[int, int] = (int(pos[0] // self.tile_size), int(pos[1] // self.tile_size))
        for offset in NEIGHBOR_OFFSETS:
            check_location: str = str(tile_location[0] + offset[0]) + ';' + str(tile_location[1] + offset[1])
            if check_location in self.tilemap:
                tiles.append(self.tilemap[check_location])
        return tiles
    
    def save(self, path: str) -> None:
        data: dict = {
            'tilemap': {
                k: tile.to_dict() for k, tile in self.tilemap.items()
            },
            'tile_size': self.tile_size,
            'offgrid': [
                tile.to_dict() for tile in self.offgrid_tiles
            ],
        }
        with open(path, 'w') as f:
            json.dump(data, f)
        
    
    def load(self, path: str) -> None:
        with open(path, 'r') as f:
            map_data = json.load(f)
        
        self.tile_size: int = map_data['tile_size']

        # Grid-Tiles: Dict -> Tile-Objekte
        self.tilemap: dict[str, Tile] = {}
        for key, tile_data in map_data['tilemap'].items():
            self.tilemap[key] = Tile.from_dict(tile_data)
        
        # Offgrid-Tiles: Dict -> Tile-Objekte
        self.offgrid_tiles: list[Tile] = [
            Tile.from_dict(t) for t in map_data['offgrid']
        ]

    def physics_rects_around(self, pos: tuple[float, float]) -> list[pygame.Rect]:
        rects: list[pygame.Rect] = []
        for tile in self.tiles_around(pos):
            if tile.type in PHYSICS_TILES:
                rects.append(pygame.Rect(tile.pos[0] * self.tile_size, tile.pos[1] * self.tile_size, self.tile_size, self.tile_size))
        return rects
    
    def autotile(self):
        for loc in self.tilemap:
            tile: Tile = self.tilemap[loc]
            neighbors: set[tuple[int, int]] = set()
            for shift in [(1, 0), (-1, 0), (0, -1), (0, 1)]:
                check_loc: str = str(tile.pos[0] + shift[0]) + ';' + str(tile.pos[1] + shift[1])
                if check_loc in self.tilemap:
                    if self.tilemap[check_loc].type == tile.type:
                        neighbors.add(shift)
            neighbors: tuple[tuple[int, int], ...] = tuple(sorted(neighbors))
            if (tile.type in AUTOTILE_TYPES) and (neighbors in AUTOTILE_MAP):
                tile.variant = AUTOTILE_MAP[neighbors]
    
    def render(self, surface: pygame.Surface, offset: tuple[float, float] = (0, 0)) -> None:
        for tile in self.offgrid_tiles:
            surface.blit(
                self.game.assets[tile.type][tile.variant], 
                (tile.pos[0] - offset[0], tile.pos[1] - offset[1])
            )
 
        for x in range(offset[0] // self.tile_size, 
                      (offset[0] + surface.get_width()) // self.tile_size + 1):
            for y in range(offset[1] // self.tile_size, 
                      (offset[1] + surface.get_height()) // self.tile_size + 1):
                location_key: str = str(x) + ';' + str(y)
                if location_key in self.tilemap:
                    tile: Tile = self.tilemap[location_key]
                    surface.blit(
                        self.game.assets[tile.type][tile.variant], 
                                 (
                                    tile.pos[0] * self.tile_size - offset[0], 
                                    tile.pos[1] * self.tile_size - offset[1])
                                )