Tipp für die Zukunft: Bevor du eine Instanzvariable (wie z. B. self.light_points" erstellst, überlege dir zuerst, ob es sich um Daten handelt, die du an verschiedenen Stellen erreichen musst. Denn nur dafür sollten Instanzvariablen angelegt werden.
152 lines
5.1 KiB
Python
152 lines
5.1 KiB
Python
import pygame
|
|
from pygame.math import Vector2
|
|
from pygame.rect import Rect
|
|
|
|
SCREEN_WIDTH = 1280
|
|
SCREEN_HEIGHT = 720
|
|
PLAYER_SIZE = 20
|
|
LIGHT_RADIUS = 75
|
|
|
|
|
|
class Game:
|
|
def __init__(self):
|
|
# Pygame setup
|
|
pygame.init()
|
|
pygame.display.set_caption("School Game")
|
|
self.clock = pygame.Clock()
|
|
# Surfaces
|
|
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-Variablen
|
|
self.running: bool = True
|
|
self.dt: int = 0
|
|
# Spieler
|
|
self.player_pos = pygame.Vector2(self.display.get_width() / 2, self.display.get_height() / 2)
|
|
self.player = Player(self, self.player_pos, width=PLAYER_SIZE, height=PLAYER_SIZE)
|
|
# Items
|
|
self.item_rect = pygame.Rect(70, 150, 10, 10)
|
|
self.flashlight_rect = pygame.Rect(0, 0, 0, 0)
|
|
self.color_item = (0, 0, 0)
|
|
# Level
|
|
self.walls = [pygame.Rect(100, 100, 20, 50), pygame.Rect(300, 300, 200, 20), pygame.Rect(550, 80, 20, 200)]
|
|
# Licht
|
|
self.light_points: list[pygame.Vector2]
|
|
|
|
def run(self) -> None:
|
|
while self.running:
|
|
self.dt: float = self.clock.tick(60) / 1000.0
|
|
|
|
self.update()
|
|
self.calculate_collsions()
|
|
self.render()
|
|
|
|
def update(self) -> None:
|
|
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_LSHIFT:
|
|
self.player.speed = 300
|
|
if event.type == pygame.KEYUP and event.key == pygame.K_LSHIFT:
|
|
self.player.speed = 150
|
|
|
|
self.player.update(walls=self.walls, dt=self.dt)
|
|
self.light_points: list[Vector2] = self.create_light_points()
|
|
|
|
|
|
def create_light_points(self)-> list[pygame.Vector2]:
|
|
light_points: list[pygame.Vector2] = []
|
|
vector = pygame.Vector2(LIGHT_RADIUS, 0)
|
|
|
|
# Lichtstrahlen berechnen
|
|
for i in range(360):
|
|
rotated_vector = vector.rotate(i)
|
|
ray_end = self.player_pos + rotated_vector
|
|
|
|
# Überschneidung mit den Wänden prüfen
|
|
for wall in self.walls:
|
|
überschneidung = wall.clipline(self.player_pos, ray_end)
|
|
if überschneidung:
|
|
schnittpunkt = pygame.Vector2(überschneidung[0])
|
|
ray_end = schnittpunkt
|
|
light_points.append(ray_end)
|
|
return light_points
|
|
|
|
def render(self) -> None:
|
|
|
|
self.display.fill((0, 0, 0, 0))
|
|
|
|
self.flashlight_rect: Rect = pygame.draw.polygon(self.display, (243, 255, 74), self.light_points)
|
|
self.player.render(surface=self.display)
|
|
pygame.draw.rect(self.display, self.color_item, self.item_rect)
|
|
|
|
for wall in self.walls:
|
|
pygame.draw.rect(self.display, "grey", wall)
|
|
|
|
self.screen.blit(pygame.transform.scale(self.display, self.screen.get_size()))
|
|
pygame.display.update()
|
|
|
|
def calculate_collsions(self) -> None:
|
|
pass
|
|
|
|
|
|
class Player:
|
|
def __init__(self, game, pos: pygame.Vector2, width, height):
|
|
self.game = game
|
|
self.pos = pos
|
|
self.width = width
|
|
self.height = height
|
|
self.speed = 150
|
|
self.rect = pygame.Rect(self.pos[0] - self.width / 2, self.pos[1] - self.height / 2, width, height)
|
|
|
|
def update(self, walls, dt):
|
|
|
|
# Smooth Movement
|
|
keys = pygame.key.get_pressed()
|
|
direction = pygame.Vector2(keys[pygame.K_d] - keys[pygame.K_a], keys[pygame.K_s] - keys[pygame.K_w])
|
|
|
|
if direction.length_squared() > 0:
|
|
direction = direction.normalize()
|
|
|
|
movement: pygame.Vector2 = direction * self.speed * dt
|
|
|
|
self.pos.x += movement.x
|
|
|
|
if self.pos.x - self.width / 2 < 0:
|
|
self.pos.x = self.width / 2
|
|
if self.pos.x + self.width / 2 > SCREEN_WIDTH / 2:
|
|
self.pos.x = SCREEN_WIDTH / 2 - self.width / 2
|
|
self.rect.centerx = round(self.pos.x)
|
|
|
|
for wall in walls:
|
|
if self.rect.colliderect(wall):
|
|
if movement.x > 0:
|
|
self.rect.right = wall.left
|
|
elif movement.x < 0:
|
|
self.rect.left = wall.right
|
|
self.pos.x = self.rect.centerx
|
|
|
|
self.pos.y += movement.y
|
|
|
|
if self.pos.y - self.height / 2 < 0:
|
|
self.pos.y = self.height / 2
|
|
if self.pos.y + self.height / 2 > SCREEN_HEIGHT / 2:
|
|
self.pos.y = SCREEN_HEIGHT / 2 - self.height / 2
|
|
self.rect.centery = round(self.pos.y)
|
|
|
|
for wall in walls:
|
|
if self.rect.colliderect(wall):
|
|
if movement.y > 0:
|
|
self.rect.bottom = wall.top
|
|
elif movement.y < 0:
|
|
self.rect.top = wall.bottom
|
|
self.pos.y = self.rect.centery
|
|
|
|
def render(self, surface):
|
|
pygame.draw.rect(surface, (255, 0, 0), self.rect)
|
|
|
|
|
|
game = Game()
|
|
game.run()
|