353 lines
13 KiB
Python
353 lines
13 KiB
Python
import pygame # ty: ignore[unresolved-import]
|
|
import sys
|
|
import random
|
|
import math
|
|
import os
|
|
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
|
|
from scripts.spark import Spark
|
|
|
|
|
|
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),
|
|
pygame.SRCALPHA,
|
|
)
|
|
self.display_2: 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(path="gun.png"),
|
|
"projectile": load_image(path="projectile.png"),
|
|
}
|
|
|
|
self.sfx = {
|
|
"jump": pygame.mixer.Sound("data/sfx/jump.wav"),
|
|
"dash": pygame.mixer.Sound("data/sfx/dash.wav"),
|
|
"hit": pygame.mixer.Sound("data/sfx/hit.wav"),
|
|
"shoot": pygame.mixer.Sound("data/sfx/shoot.wav"),
|
|
"ambience": pygame.mixer.Sound("data/sfx/ambience.wav"),
|
|
}
|
|
|
|
self.sfx["ambience"].set_volume(0.2)
|
|
self.sfx["shoot"].set_volume(0.4)
|
|
self.sfx["hit"].set_volume(0.8)
|
|
self.sfx["dash"].set_volume(0.3)
|
|
self.sfx["jump"].set_volume(0.7)
|
|
|
|
|
|
self.player: Player = Player(game=self, pos=(50, 50), size=(8, 15))
|
|
|
|
self.tilemap: Tilemap = Tilemap(game=self, tile_size=16)
|
|
|
|
self.level: int | str = "jays_map"
|
|
|
|
self.load_level(map_id=self.level)
|
|
self.screenshake = 0
|
|
|
|
self.clouds: Clouds = Clouds(cloud_images=self.assets["clouds"], count=16)
|
|
self.isJumping: bool = False
|
|
# self.boost: bool = False
|
|
|
|
def load_level(self, map_id: str | int):
|
|
try:
|
|
self.tilemap.load(path="data/maps/" + str(object=map_id) + ".json")
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
self.leaf_spawners: list[pygame.Rect] = []
|
|
self.enemies: list[Enemy] = []
|
|
|
|
for tree in self.tilemap.extract(id_pairs=[("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(
|
|
id_pairs=[("spawners", 0), ("spawners", 1)]
|
|
):
|
|
if spawner["variant"] == 0:
|
|
self.player.pos = spawner["pos"]
|
|
self.player.air_time = 0
|
|
else:
|
|
self.enemies.append(Enemy(game=self, pos=spawner["pos"], size=(8, 15)))
|
|
|
|
self.particles: list[Particle] = []
|
|
self.projectiles: list = []
|
|
self.sparks: list[Spark] = []
|
|
self.dead: int = 0
|
|
self.scroll: list[float] = [0, 0]
|
|
self.transition: int = -30
|
|
|
|
def run(self) -> None:
|
|
pygame.mixer.music.load("data/music.wav")
|
|
pygame.mixer.music.set_volume(0.5)
|
|
pygame.mixer.music.play(loops=-1)
|
|
|
|
self.sfx["ambience"].play(loops=-1)
|
|
|
|
while self.running:
|
|
self.display.fill((0, 0, 0, 0))
|
|
self.display_2.blit(self.assets["background"], (0, 0))
|
|
|
|
if self.dead:
|
|
self.dead += 1
|
|
self.screenshake = max(16, self.screenshake)
|
|
if self.dead > 40:
|
|
self.load_level(map_id=self.level)
|
|
|
|
self.screenshake = max(0, self.screenshake - 1)
|
|
|
|
if not len(self.enemies):
|
|
self.transition += 1
|
|
if self.transition > 30:
|
|
self.level = min(self.level + 1, len(os.listdir("data/maps")) - 1)
|
|
self.load_level(self.level)
|
|
if self.transition < 0:
|
|
self.transition += 1
|
|
|
|
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: tuple = (
|
|
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(a=0, b=20),
|
|
)
|
|
)
|
|
|
|
self.clouds.update()
|
|
self.clouds.render(surface=self.display_2, offset=render_scroll)
|
|
self.tilemap.render(surface=self.display, offset=render_scroll)
|
|
for enemy in self.enemies.copy():
|
|
kill = enemy.update(self.tilemap, movement=(0, 0))
|
|
enemy.render(surface=self.display, offset=render_scroll)
|
|
if kill:
|
|
self.enemies.remove(enemy)
|
|
if not self.dead:
|
|
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(pos=projectile[0]):
|
|
self.projectiles.remove(projectile)
|
|
for _ in range(4):
|
|
self.sparks.append(
|
|
Spark(
|
|
projectile[0],
|
|
random.random()
|
|
- 0.5
|
|
+ (math.pi if projectile[1] > 0 else 0),
|
|
2 + random.random(),
|
|
)
|
|
)
|
|
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.dead += 1
|
|
for _ in range(30):
|
|
angle = random.random() * math.pi * 2
|
|
speed = random.random() * 5
|
|
self.sparks.append(
|
|
Spark(
|
|
self.player.rect().center,
|
|
angle,
|
|
2 + random.random(),
|
|
)
|
|
)
|
|
self.particles.append(
|
|
Particle(
|
|
self,
|
|
"particle",
|
|
self.player.rect().center,
|
|
velocity=[
|
|
math.cos(angle + math.pi) * speed * 0.5,
|
|
math.sin(angle + math.pi) * speed * 0.5,
|
|
],
|
|
frame=random.randint(0, 7),
|
|
)
|
|
)
|
|
|
|
for spark in self.sparks.copy():
|
|
kill = spark.update()
|
|
spark.render(self.display, offset=render_scroll)
|
|
if kill:
|
|
self.sparks.remove(spark)
|
|
|
|
|
|
display_mask = pygame.mask.from_surface(self.display)
|
|
display_sillhouette = display_mask.to_surface(setcolor=(0, 0, 0, 180), unsetcolor=(0, 0, 0, 0))
|
|
for offset in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
|
self.display_2.blit(display_sillhouette, offset)
|
|
|
|
# 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
|
|
|
|
if self.transition:
|
|
transition_surface = pygame.Surface(self.display.get_size())
|
|
pygame.draw.circle(
|
|
transition_surface,
|
|
(255, 255, 255),
|
|
(self.display.get_width() // 2, self.display.get_height() // 2),
|
|
(30 - abs(self.transition)) * 8,
|
|
)
|
|
transition_surface.set_colorkey((255, 255, 255))
|
|
self.display.blit(transition_surface, (0, 0))
|
|
|
|
self.display_2.blit(self.display, (0, 0))
|
|
|
|
screenshake_offset = (
|
|
random.random() * self.screenshake - self.screenshake / 2,
|
|
random.random() * self.screenshake - self.screenshake / 2,
|
|
)
|
|
|
|
self.screen.blit(
|
|
pygame.transform.scale(self.display_2, self.screen.get_size()),
|
|
screenshake_offset,
|
|
)
|
|
|
|
pygame.display.update()
|
|
self.clock.tick(60)
|
|
|
|
pygame.quit()
|
|
sys.exit()
|
|
|
|
|
|
game = Game()
|
|
game.run()
|