103 lines
3.7 KiB
Python
103 lines
3.7 KiB
Python
import math
|
|
import time
|
|
|
|
from MoveAble import MoveAble
|
|
from Vec import Vec
|
|
import pygame as pg
|
|
|
|
|
|
class Player(MoveAble):
|
|
|
|
def __init__(self, start_position: Vec, start_size: Vec, speed, grid_cell_size, maze):
|
|
# Make the speed an even number
|
|
# speed += 0 if (speed % 2 == 0 or speed == 1) == 0 else 1
|
|
super().__init__(start_position, start_size, speed)
|
|
self.grid_cell_size = grid_cell_size
|
|
self.targetDirection = Vec(0, 0)
|
|
self.correct = False
|
|
self.score = 0
|
|
self.last_state_switched = time.time()
|
|
self.state = False
|
|
self.hp = 3
|
|
self.last_time_hit = 0
|
|
self.maze = maze
|
|
|
|
# Überschreibt den Vektor, der die Laufrichtung PacMans darstellt
|
|
def poll_keys(self, maze):
|
|
keys = pg.key.get_pressed()
|
|
free_y = self.position.x % self.grid_cell_size == 0
|
|
free_x = self.position.y % self.grid_cell_size == 0
|
|
|
|
if keys[pg.K_LEFT] or keys[pg.K_a]:
|
|
self.targetDirection = Vec(-1, 0)
|
|
|
|
if keys[pg.K_RIGHT] or keys[pg.K_d]:
|
|
self.targetDirection = Vec(1, 0)
|
|
|
|
if keys[pg.K_UP] or keys[pg.K_w]:
|
|
self.targetDirection = Vec(0, -1)
|
|
|
|
if keys[pg.K_DOWN] or keys[pg.K_s]:
|
|
self.targetDirection = Vec(0, 1)
|
|
|
|
allowed = maze.is_free(
|
|
Vec(round(self.position.x / self.grid_cell_size) + self.targetDirection.x,
|
|
round(self.position.y / self.grid_cell_size) + self.targetDirection.y))
|
|
|
|
# Erst wenn die gewünschte Laufrichtung begehbar ist, verändert sich die Laufrichtung PacMans.
|
|
if self.targetDirection.x != 0 and free_x and allowed:
|
|
self.velocity = Vec(self.targetDirection.x * self.speed, self.targetDirection.y * self.speed)
|
|
self.targetDirection = Vec(0, 0)
|
|
|
|
# Erst wenn die gewünschte Laufrichtung begehbar ist, verändert sich die Laufrichtung PacMans.
|
|
if self.targetDirection.y != 0 and free_y and allowed:
|
|
self.velocity = Vec(self.targetDirection.x * self.speed, self.targetDirection.y * self.speed)
|
|
self.targetDirection = Vec(0, 0)
|
|
|
|
def auto_place(self):
|
|
x = 15
|
|
for y in range(0, 29):
|
|
if self.maze.is_free(Vec(x, y)):
|
|
self.position = Vec(x * self.grid_cell_size, y * self.grid_cell_size)
|
|
break
|
|
|
|
self.velocity = Vec(0, 0)
|
|
|
|
def move(self):
|
|
|
|
# Rechne die Position von 0 - Bildschirmbreite, 0 - Bildschirmhöhe in 0-30, 0-30 um
|
|
test = Vec(self.position.x / self.grid_cell_size,
|
|
self.position.y / self.grid_cell_size)
|
|
|
|
# Mache die Komponenten (je nach richtung der Geschwindigkeit) zu Integer-Datentypen.
|
|
test.x = math.ceil(test.x) if self.velocity.x < 0 else math.floor(test.x)
|
|
test.y = math.ceil(test.y) if self.velocity.y < 0 else math.floor(test.y)
|
|
|
|
# Speichere die Richtung der Geschwindigkeit als Vektor der länge 1 ab
|
|
check_direction = self.velocity.get_normalized()
|
|
check_direction.to_int()
|
|
|
|
# Füge diese Richtung der Test (Position von Pacman im 30x30 Gitter) hinzu
|
|
test.add(check_direction)
|
|
|
|
# Überprüfe, ob das Labyrinth an der Stelle des resultierenden test Vektor frei ist (keine Wand bzw. 0)
|
|
if self.maze.is_free(test):
|
|
super().move()
|
|
|
|
def get_rotation(self):
|
|
player_rot = 0
|
|
if self.velocity.x < 0:
|
|
player_rot = 180
|
|
if self.velocity.y < 0:
|
|
player_rot = 90
|
|
if self.velocity.y > 0:
|
|
player_rot = -90
|
|
|
|
return player_rot
|
|
|
|
def get_state(self):
|
|
if time.time() - self.last_state_switched > 0.2:
|
|
self.state = not self.state
|
|
self.last_state_switched = time.time()
|
|
return self.state
|