Ninja-Jump-and-run/game.py

import pygame  # ty: ignore[unresolved-import]
import sys
import random
import math
from scripts.entities import Enemy, Player
from scripts.utils import load_image
from scripts.utils import load_images
from scripts.tilemap import Tilemap
from scripts.clouds import Clouds
from scripts.animation import Animation
from scripts.particle import Particle

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480


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

        pygame.display.set_caption("Jump and run spiel")
        self.screen: pygame.Surface = pygame.display.set_mode(
            (SCREEN_WIDTH, SCREEN_HEIGHT)
        )
        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.running: bool = True

        self.collision_area: pygame.Rect = pygame.Rect(50, 50, 300, 50)
        self.movement: list[bool] = [False, False]

        self.assets: dict = {
            # Andere Dinge
            "background": load_image(path="background.png"),
            "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"),
            "clouds": load_images(path="clouds"),
            # Spieler
            "player/idle": Animation(
                load_images(path="entities/player/idle"), image_duration=6
            ),
            "player/run": Animation(
                load_images(path="entities/player/run"), image_duration=4
            ),
            "player/jump": Animation(load_images(path="entities/player/jump")),
            "player/slide": Animation(load_images(path="entities/player/slide")),
            "player/wall_slide": Animation(
                load_images(path="entities/player/wall_slide")
            ),
            "enemy/idle": Animation(
                load_images(path="entities/enemy/idle"), image_duration=6
            ),
            "enemy/run": Animation(
                load_images(path="entities/enemy/run"), image_duration=4
            ),
            "particles/leaf": Animation(
                load_images(path="particles/leaf"), image_duration=20, loop=False
            ),
            "particles/boost": Animation(
                load_images(path="particles/boost"), image_duration=20, loop=False
            ),
            "particles/particle": Animation(
                load_images(path="particles/particle"), image_duration=6, loop=False
            ),
            "gun": load_image("gun.png"),
            "projectile": load_image("projectile.png"),
        }
        self.player: Player = Player(game=self, pos=(50, 50), size=(8, 15))

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

        self.load_level(0)

        self.leaf_spawners: list[pygame.Rect] = []
        self.enemys: list[Enemy] = []

        for tree in self.tilemap.extract([("large_decor", 2)], keep=True):
            self.leaf_spawners.append(
                pygame.Rect(4 + tree["pos"][0], 4 + tree["pos"][1], 23, 13)
            )

        for spawner in self.tilemap.extract([("spawners", 0), ("spawners", 1)]):
            if spawner["variant"] == 0:
                self.player.pos = spawner["pos"]
            else:
                self.enemys.append(Enemy(self, spawner["pos"], (8, 15)))

        self.particles: list[Particle] = []
        self.projectiles: list = []

        self.clouds: Clouds = Clouds(cloud_images=self.assets["clouds"], count=16)
        self.isJumping: bool = False
        self.scroll: list[float] = [0, 0]
        # self.boost: bool = False

    def load_level(self, map_id: int):
        try:
            self.tilemap.load(path="data/maps/" + str(map_id) + ".json")
        except FileNotFoundError:
            pass

    def run(self) -> None:
        while self.running:
            self.display.blit(self.assets["background"], (0, 0))

            self.scroll[0] += (
                self.player.rect().centerx
                - self.display.get_width() / 2
                - self.scroll[0]
            ) / 30
            self.scroll[1] += (
                self.player.rect().centery
                - self.display.get_height() / 2
                - self.scroll[1]
            ) / 30
            render_scroll: tuple[int, int] = (int(self.scroll[0]), int(self.scroll[1]))

            for rect in self.leaf_spawners:
                if random.random() * 49999 < rect.width * rect.height:
                    pos = (
                        rect.x + random.random() * rect.width,
                        rect.y + random.random() * rect.height,
                    )
                    self.particles.append(
                        Particle(
                            self,
                            "leaf",
                            pos,
                            velocity=[-0.1, 0.3],
                            frame=random.randint(0, 20),
                        )
                    )

            self.clouds.update()
            self.clouds.render(surface=self.display, offset=render_scroll)
            self.tilemap.render(surface=self.display, offset=render_scroll)
            for enemy in self.enemys.copy():
                enemy.update(self.tilemap, (0, 0))
                enemy.render(self.display, offset=render_scroll)
            self.player.update(
                self.tilemap, movement=((self.movement[1] - self.movement[0]), 0)
            )
            self.player.render(surface=self.display, offset=render_scroll)


            # [[x, y], direction, timer]
            for projectile in self.projectiles.copy():
                projectile[0][0] += projectile[1]
                projectile[2] += 1
                img = self.assets["projectile"]
                self.display.blit(
                    img,
                    (
                        projectile[0][0] - img.get_width() / 2 - render_scroll[0],
                        projectile[0][1] - img.get_height() / 2 - render_scroll[1],
                    ),
                )
                if self.tilemap.solid_check(projectile[0]):
                    self.projectiles.remove(projectile)
                elif projectile[2] > 360:
                    self.projectiles.remove(projectile)
                elif abs(self.player.dashing) < 50:
                    if self.player.rect().collidepoint(projectile[0]):
                        self.projectiles.remove(projectile)


            # self.player.boost(self.boost)
            # print(int(self.player.pos[0]))
            # print(int(self.player.pos[1]))
            # print(self.tilemap.tiles_around(self.player.pos))
            for particle in self.particles.copy():
                kill: bool = particle.update()
                particle.render(self.display, offset=render_scroll)
                if particle.type == "leaf":
                    particle.pos[0] += math.sin(particle.animation.frame * 0.035) * 0.3
                if kill:
                    self.particles.remove(particle)

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = 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_SPACE or event.key == pygame.K_w
                    ):  # and not self.isJumping
                        self.player.jump()

                    if event.key == pygame.K_m:
                        # self.boost = True
                        self.player.boost()

                    if event.key == pygame.K_x or event.key == pygame.K_LSHIFT or event.key == pygame.K_RSHIFT:
                        self.player.dash()

                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_m:
                        self.boost = False

            self.screen.blit(
                pygame.transform.scale(self.display, self.screen.get_size()), (0, 0)
            )

            pygame.display.update()
            self.clock.tick(60)

        pygame.quit()
        sys.exit()


game = Game()
game.run()