Wieder so wie vorher

This commit is contained in:
Benjamin 2026-11-11 17:54:46 +01:00
parent 8b42ab04f1
commit a97f46b127
4 changed files with 101 additions and 113 deletions

38
game.py
View file

@ -2,7 +2,6 @@ import pygame
from scripts.constants import *
from scripts.flashlight import Flashlight
from scripts.gegner import Gegner
from scripts.level import Level
from scripts.player import Player
from scripts.utils import load_image
@ -19,18 +18,12 @@ class Game:
self.screen: pygame.Surface = pygame.display.set_mode(
(SCREEN_WIDTH, SCREEN_HEIGHT)
)
self.gegner = Gegner((100, 300))
self.world_surface = pygame.Surface(
self.screen.get_size(), pygame.SRCALPHA
).convert_alpha()
# Pygame-Variablen
self.running: bool = True
self.dt: int = 0
# Spieler
self.player_pos = pygame.Vector2(
self.screen.get_width() / 2, self.screen.get_height() / 2-200
self.screen.get_width() / 2, self.screen.get_height() / 2
)
@ -38,9 +31,9 @@ class Game:
self.assets = {
"floor_01": load_image("level/ground/floor_1.png"),
"plant_01": load_image("items/furniture/plants/plant.png"),
"wall": load_image("level/walls/wall_0.png").convert_alpha(),
"wall": load_image("level/walls/wall_0.png"),
"player": load_image("entity/player/player.png").convert_alpha(),
"player": load_image("entity/player/player.png"),
}
self.player = Player(self.player_pos, width=PLAYER_SIZE, height=PLAYER_SIZE, image=self.assets["player"])
self.flashlight_player = Flashlight(self, self.player)
@ -49,14 +42,13 @@ class Game:
game=self,
items=[],
walls=[
# Wall(self, 0, 0, SCREEN_WIDTH//TILE_SIZE, 1),
# Wall(self, 0, TILE_SIZE, 1, SCREEN_HEIGHT//TILE_SIZE),
# Wall(
# self, TILE_SIZE, SCREEN_HEIGHT - TILE_SIZE, SCREEN_WIDTH//TILE_SIZE, 1
# ),
# Wall(self, SCREEN_WIDTH - TILE_SIZE, 0, 1, SCREEN_HEIGHT//TILE_SIZE),
# Wall(self, 500, 500, 2, 2)
Wall(self, 300, 300, 1, 1)
Wall(self, 0, 0, SCREEN_WIDTH//TILE_SIZE, 1),
Wall(self, 0, TILE_SIZE, 1, SCREEN_HEIGHT//TILE_SIZE),
Wall(
self, TILE_SIZE, SCREEN_HEIGHT - TILE_SIZE, SCREEN_WIDTH//TILE_SIZE, 1
),
Wall(self, SCREEN_WIDTH - TILE_SIZE, 0, 1, SCREEN_HEIGHT//TILE_SIZE),
Wall(self, 500, 500, 2, 2)
],
)
@ -84,19 +76,12 @@ class Game:
self.flashlight_player.light_state = (
not self.flashlight_player.light_state
)
if event.key == pygame.K_f:
self.gegner.angreifen()
elif event.key == pygame.K_x:
self.gegner.sterben()
if event.type == pygame.KEYUP and event.key == pygame.K_LSHIFT:
self.player.speed = 150
# Spielzustände aktualisieren
self.gegner.update(self.dt, (1, 1))
self.player.update(walls=self.walls, dt=self.dt)
self.level.update()
self.flashlight_player.update()
for item in self.items:
@ -104,11 +89,10 @@ class Game:
def render(self) -> None:
# Hintergrund
self.screen.fill((0, 0, 0, 0))
self.level.render(self.screen)
self.gegner.render(self.screen)
# 1. Zeichne 1 Tile -> []
# 2. Zeichne eine Reihe von Tiles -> [][][][][][]

View file

@ -5,14 +5,15 @@ from scripts.constants import *
class Player:
def __init__(self, pos: pygame.Vector2, width, height, image: pygame.Surface=None):
def __init__(self, pos: pygame.Vector2, width, height, image=None):
self.pos: Vector2 = pos
self.width: float = width
self.height: float = height
self.speed = 150
self.image = image
self.mask = pygame.mask.from_surface(self.image)
self.rect = image.get_frect()
self.rect = pygame.Rect(
self.pos[0] - self.width / 2, self.pos[1] - self.height / 2, width, height
)
def update(self, walls, dt):
@ -24,8 +25,6 @@ class Player:
if direction.length_squared() > 0:
direction = direction.normalize()
movement: pygame.Vector2 = direction * self.speed * dt
self.pos.x += movement.x
@ -37,14 +36,12 @@ class Player:
self.rect.centerx = round(self.pos.x)
for wall in walls:
offset = (int(self.rect.x) - int(wall.rect.x), int(self.rect.y) - int(wall.rect.y))
wall_rect = wall.get_rect()
if self.mask.overlap(wall.mask, offset):
wall = wall.get_rect()
if self.rect.colliderect(wall):
if movement.x > 0:
self.rect.right = wall_rect.left
self.rect.right = wall.left
elif movement.x < 0:
self.rect.left = wall_rect.right
self.rect.left = wall.right
self.pos.x = self.rect.centerx
self.pos.y += movement.y
@ -56,14 +53,12 @@ class Player:
self.rect.centery = round(self.pos.y)
for wall in walls:
offset = (int(self.rect.x) - wall.rect.x, int(self.rect.y) - wall.rect.y)
wall_rect = wall.get_rect()
if self.mask.overlap(wall.mask, offset):
wall = wall.get_rect()
if self.rect.colliderect(wall):
if movement.y > 0:
self.rect.bottom = wall_rect.top
self.rect.bottom = wall.top
elif movement.y < 0:
self.rect.top = wall_rect.bottom
self.rect.top = wall.bottom
self.pos.y = self.rect.centery
@ -72,6 +67,6 @@ class Player:
pygame.draw.rect(surface, self.color, self.rect)
else:
surface.blit(
self.mask.to_surface(),
self.image,
(self.pos[0]-TILE_SIZE/2, self.pos[1]-TILE_SIZE/2-10, self.image.get_width(), self.image.get_height()),
)

View file

@ -10,12 +10,11 @@ class Wall:
self.y = y
self.cols = cols
self.rows = rows
self.image = self.game.assets["wall"]
self.rect = pygame.FRect(x, y, cols*TILE_SIZE, rows*TILE_SIZE)
self.mask = self.mask = pygame.Mask(self.rect.size, fill=True)
self.rect = pygame.Rect(x, y, cols*TILE_SIZE, rows*TILE_SIZE)
self.drawed_rect = None
self.grid: list[list[pygame.Rect]] = []
for row in range(self.rows): # rows
current_row = []
for col in range(self.cols): # cols
@ -23,16 +22,14 @@ class Wall:
self.grid.append(current_row)
self.see_rect = self.mask.get_rect()
print(f"X: {self.see_rect.x}, Y: {self.see_rect.y}")
def update(self):
pass
def render(self, surface: pygame.Surface):
for row in self.grid:
for wall_rect in row:
surface.blit(self.mask.to_surface(), wall_rect)
surface.blit(self.game.assets["wall"], wall_rect)
pygame.draw.rect(surface, "red", self.see_rect, 1)
def get_rect(self) -> pygame.Rect:
return self.rect

View file

@ -1,92 +1,104 @@
from pathlib import Path
import pygame
from player import Player
# pygame setup
pygame.init()
WINDOW_WIDTH = 640
WINDOW_HEIGHT = 580
CENTER_X = WINDOW_WIDTH / 2
CENTER_Y = WINDOW_HEIGHT / 2
window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
screen = pygame.display.set_mode((1280, 720))
clock = pygame.time.Clock()
speed = 200
radius = 50
player_pos = pygame.Vector2(CENTER_X - 50, CENTER_Y - 50)
player = Player("white", pygame.image.load(Path("./testen/player.png")), player_pos)
obstacles = [pygame.Rect((CENTER_X + 100, CENTER_Y - 100), (200, 200))]
running = True
dt = 0
player_pos = pygame.Vector2(screen.get_width() / 2, screen.get_height() / 2)
speed = 300
velocity = [0, 0]
walls = [
pygame.Rect(640, 260, 600, 30)
]
player_rect = pygame.Rect(player_pos.x, player_pos.y, 40, 40)
player_rect.center = player_pos
while running:
dt = clock.tick(60) / 1000.0
dt = clock.tick(60) / 1000
# poll for events
# pygame.QUIT event means the user clicked X to close your window
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
player.update(obstacles)
movement = dt * speed
movement_x = 0
movement_y = 0
# fill the screen with a color to wipe away anything from last frame
screen.fill("purple")
for wall in walls:
pygame.draw.rect(screen, "red", wall)
pygame.draw.rect(screen, "blue", player_rect)
pygame.draw.line(screen, "yellow", (0, 0), player_pos)
velocity = [0, 0]
keys = pygame.key.get_pressed()
if keys[pygame.K_w]:
movement_y -= movement
if keys[pygame.K_s]:
movement_y += movement
if keys[pygame.K_a]:
movement_x -= movement
if keys[pygame.K_d]:
movement_x += movement
steps = int(movement) + 1
step_x = movement_x / steps
step_y = movement_y / steps
for step in range(steps):
previous_x = player.pos.x
player.pos.x += step_x
direction = pygame.Vector2(
keys[pygame.K_d] - keys[pygame.K_a],
keys[pygame.K_s] - keys[pygame.K_w]
)
if player.pos.x - player.rect.width/2 < 0:
player.pos.x = player.rect.width/2
if player.pos.x + player.rect.width/2 > WINDOW_WIDTH:
player.pos.x = WINDOW_WIDTH - player.rect.width/2
movement = direction * speed * dt
if player.overlaps_rect(obstacle):
player.pos.x = previous_x
player_pos += movement
previous_y = player.pos.y
player.pos.y += step_y
# player_rect.center = round(player_pos)
player_rect.centerx = round(player_pos.x)
if player.pos.y - player.rect.height/2 < 0:
player.pos.y = player.rect.height/2
if player.pos.y + player.rect.height/2 > WINDOW_HEIGHT:
player.pos.y = WINDOW_HEIGHT - player.rect.height/2
for wall in walls:
if player_rect.colliderect(wall):
if movement.x > 0:
player_rect.right = wall.left
if player.overlaps_rect(obstacle):
player.pos.y = previous_y
elif movement.x < 0:
player_rect.left = wall.right
player_pos.x = player_rect.centerx
player_rect.centery = round(player_pos.y)
for wall in walls:
if player_rect.colliderect(wall):
if movement.y > 0:
player_rect.bottom = wall.top
elif movement.y < 0:
player_rect.top = wall.bottom
player_pos.y = player_rect.centery
window.fill(player.color)
pygame.draw.rect(window, "grey", obstacle)
player.render(window)
# flip() the display to put your work on screen
pygame.display.flip()
# limits FPS to 60
# dt is delta time in seconds since last frame, used for framerate-
# independent physics.
pygame.quit()
"""
Hausaufgabe: Pixelgenaue Kollision zwischen dem Spielerbild und der Wand ohne ruckeln, geschmeidig + MASKE D:
'Die Hausaufgabe ist, eine pixelgenaue Kollision zwischen dem Spielerbild und der Wand hinzubekommen, ohne zu ruckeln,
sodass du dich geschmeidig entlang der Wand bewegen kannst und eine Maske verwendest.'
"""