Ninja-Jump-and-run/editor.py

import pygame
import sys

from scripts.tilemap import Tilemap
from scripts.utils import load_images
from scripts.models import Tile

RENDER_SCALE = 2.0


class Editor:
    def __init__(self):
        pygame.init()

        pygame.display.set_caption("Editor")
        self.screen: pygame.Surface = pygame.display.set_mode((640, 480))
        self.display: pygame.Surface = pygame.Surface((self.screen.get_width()//2, self.screen.get_height()//2))

        self.clock: pygame.time.Clock = pygame.time.Clock()

        self.assets: dict[str, list[pygame.Surface]] = {
            "decor": load_images(path="tiles/decor"),
            "grass": load_images(path="tiles/grass"),
            "large_decor": load_images(path="tiles/large_decor"),
            "stone": load_images(path="tiles/stone"),
        }

        self.movement: list[bool] = [False, False, False, False]

        self.tilemap: Tilemap = Tilemap(game=self, tile_size=16)

        try:
            self.tilemap.load(path="map.json")
        except FileNotFoundError:
            pass

        self.scroll: list[float] = [0, 0]

        self.tile_list: list[str] = list(self.assets)
        self.tile_group: int = 0
        self.tile_variant: int = 0

        self.clicking: bool = False
        self.right_clicking: bool = False
        self.shift: bool = False
        self.ongrid: bool = True
        self.running = True

    def run(self):
        while self.running:
            # Hintergrund löschen
            self.display.fill((0, 0, 0))

            # Kamera-Steuerung
            self.scroll[0] += (self.movement[1] - self.movement[0]) * 2
            self.scroll[1] += (self.movement[3] - self.movement[2]) * 2

            # Scroll-Offset fürs Rendern
            render_scroll: tuple[int, int] = (int(self.scroll[0]), int(self.scroll[1]))
            #
            self.tilemap.render(surface=self.display, offset=render_scroll)

            # Aktuelle Kachel (Kopie)
            current_tile_img: pygame.Surface = self.assets[self.tile_list[self.tile_group]][
                self.tile_variant
            ].copy()
            # Halbtransparent
            current_tile_img.set_alpha(100)

            # Mausposition (Screen)
            mpos: tuple[int, int] = pygame.mouse.get_pos()
            # Auf Display-Koordinaten skalieren
            mpos: tuple[float, float] = (mpos[0] / RENDER_SCALE, mpos[1] / RENDER_SCALE)

            # Kachelkoordinate unter der Maus
            tile_pos: tuple[int, int] = (
                int((mpos[0] + self.scroll[0]) // self.tilemap.tile_size),
                int((mpos[1] + self.scroll[1]) // self.tilemap.tile_size),
            )

            # Wenn 'ongrid" aktiviert ist...
            if self.ongrid:
                # Zeige Tile-Vorschau an der aktuellen Grid-Position an
                self.display.blit(
                    current_tile_img,
                    (
                        tile_pos[0] * self.tilemap.tile_size - self.scroll[0],
                        tile_pos[1] * self.tilemap.tile_size - self.scroll[1],
                    ),
                )
            else:
                # Zeige Tile-Vorschau an der Mausposition an
                self.display.blit(current_tile_img, mpos)

            # Linksklick: Kachel platzieren
            if self.clicking:
                if self.ongrid:
                    # Tile in Tilemap setzen
                    key: str = f"{tile_pos[0]};{tile_pos[1]}"
                    self.tilemap.tilemap[key] = Tile(
                        type=self.tile_list[self.tile_group],
                        variant=self.tile_variant,
                        pos=list(tile_pos),
                    )
                else:
                    # Offgrid Tile direkt platzieren
                    world_pos: tuple[int, int] = (
                        int(mpos[0] + self.scroll[0]),
                        int(mpos[1] + self.scroll[1]),
                    )
                    self.tilemap.offgrid_tiles.append(
                        Tile(
                            type=self.tile_list[self.tile_group],
                            variant=self.tile_variant,
                            pos=list(world_pos),
                        )
                    )
            # Rechtsklick: Lösche Tile
            if self.right_clicking:
                # Hole Position des anvisierten Tile-Objekts
                tile_loc: str = str(object=tile_pos[0]) + ";" + str(tile_pos[1])
                # Wenn Tile in Tilemap existiert, lösche es.
                if tile_loc in self.tilemap.tilemap:
                    del self.tilemap.tilemap[tile_loc]
                for tile in self.tilemap.offgrid_tiles.copy():
                    tile_img: pygame.Surface = self.assets[tile.type][tile.variant]
                    tile_r: pygame.Rect = pygame.Rect(
                        tile.pos[0] - self.scroll[0],
                        tile.pos[1] - self.scroll[1],
                        tile_img.get_width(),
                        tile_img.get_height(),
                    )
                    if tile_r.collidepoint(mpos):
                        self.tilemap.offgrid_tiles.remove(tile)

            self.display.blit(current_tile_img, (5, 5))

            # Events verarbeiten
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False

                # Maus: platzieren/entfernen/auswählen
                if event.type == pygame.MOUSEBUTTONUP:
                    if event.button == 1:
                        self.clicking = False

                    if event.button == 3:
                        self.right_clicking = False

                if event.type == pygame.MOUSEBUTTONDOWN:
                    if event.button == 1:
                        self.clicking = True
                    if event.button == 3:
                        self.right_clicking = True

                    if event.button == 4:
                        if self.shift:
                            if (
                                self.tile_variant
                                >= len(self.assets[self.tile_list[self.tile_group]]) - 1
                            ):
                                self.tile_variant = 0
                            else:
                                self.tile_variant += 1

                        else:
                            if self.tile_group >= len(self.tile_list) - 1:
                                self.tile_group = 0
                                self.tile_variant = 0
                            else:
                                self.tile_group += 1
                                self.tile_variant = 0

                    if event.button == 5:
                        if self.shift:
                            if self.tile_variant <= 0:
                                self.tile_variant = (
                                    len(self.assets[self.tile_list[self.tile_group]])
                                    - 1
                                )  # Lösung vom Problem musste das von oben nehmen: len(self.assets[self.tile_list[self.tile_group]])-1

                            else:
                                self.tile_variant -= 1

                        else:
                            if self.tile_group <= 0:
                                self.tile_group = len(self.tile_list) - 1
                                self.tile_variant = 0

                            else:
                                self.tile_group -= 1
                                self.tile_variant = 0

                if event.type == pygame.MOUSEBUTTONUP:
                    if event.button == 1:
                        self.clicking = False
                    if event.button == 3:
                        self.right_clicking = False

                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        self.running = False
                    if event.key == pygame.K_a:
                        self.movement[0] = True
                    if event.key == pygame.K_d:
                        self.movement[1] = True
                    if event.key == pygame.K_w:
                        self.movement[2] = True
                    if event.key == pygame.K_s:
                        self.movement[3] = True
                    if event.key == pygame.K_g:
                        self.ongrid: bool = not self.ongrid
                    if event.key == pygame.K_t:
                        self.tilemap.autotile()
                    if event.key == pygame.K_o:
                        print("Map saved.")
                        self.tilemap.save(path="map.json")
                    if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
                        self.shift: bool = True
                if event.type == pygame.KEYUP:
                    if event.key == pygame.K_a:
                        self.movement[0] = False
                    if event.key == pygame.K_d:
                        self.movement[1] = False
                    if event.key == pygame.K_w:
                        self.movement[2] = False
                    if event.key == pygame.K_s:
                        self.movement[3] = False
                    if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
                        self.shift: bool = False

            # Display auf Screen skalieren
            self.screen.blit(
                pygame.transform.scale(self.display, self.screen.get_size()), (0, 0)
            )
            # Frame anzeigen
            pygame.display.update()
            # FPS limitieren
            self.clock.tick(60)

        pygame.quit()
        sys.exit()

Editor().run()