328 lines
11 KiB
Python
328 lines
11 KiB
Python
import pygame
|
|
import pygame_menu
|
|
import random as rand
|
|
|
|
pygame.init()
|
|
MAINSCREEN_SIZE = (1024,768)
|
|
MAINSCREEN = pygame.display.set_mode(MAINSCREEN_SIZE)
|
|
pygame.display.set_caption("Testgame")
|
|
|
|
WEISS = ( 255, 255, 255)
|
|
active = True
|
|
|
|
clock = pygame.time.Clock()
|
|
|
|
# Definieren der Variablen
|
|
ballpos_x = 10
|
|
ballpos_y = 10
|
|
|
|
#TODO: Make Grid for running Rect
|
|
|
|
class GameObject():
|
|
__name = str()
|
|
__last_pos_x = int()
|
|
__last_pos_y = int()
|
|
__pos_x = int()
|
|
__pos_y = int()
|
|
__color = (0,0,0)
|
|
__size_rect = {"x":60, "y":60}
|
|
__movespeed = int()
|
|
__rectobjekt = pygame.Rect
|
|
__surface = MAINSCREEN
|
|
__hide = False
|
|
__collided = False
|
|
__is_player = False
|
|
__has_follower = False
|
|
|
|
__movedirection = {"up":False, "down":False, "left":False, "right":False}
|
|
|
|
def __init__(self, name:str, posx_init:int=0, posy_init:int=0, move_speed:int=0, is_player:bool = False) -> None:
|
|
self.__name = name
|
|
self.__pos_x = posx_init
|
|
self.__pos_y = posy_init
|
|
self.__inital_pos_x = posx_init
|
|
self.__initial_pos_y = posx_init
|
|
self.__movespeed = move_speed
|
|
self.__is_player = is_player
|
|
#self.__rectobjekt = rect
|
|
|
|
def change_direction(self, direction:dict):
|
|
if(direction):
|
|
for key in self.__movedirection.keys():
|
|
self.__movedirection[key] = False
|
|
self.__movedirection[direction] = True
|
|
print(direction)
|
|
pass
|
|
|
|
def move(self, *speed:int):
|
|
MOVE_SPEED = 1
|
|
#self.__rectobjekt.x += MOVE_SPEED
|
|
|
|
if(self.__movedirection['up']):
|
|
if(not speed): self.__pos_y -= MOVE_SPEED
|
|
else: self.__pos_y -= speed[0]
|
|
if(self.__pos_y <= -self.__size_rect["y"]):
|
|
self.__pos_y = MAINSCREEN_SIZE[1]
|
|
|
|
elif(self.__movedirection['down']):
|
|
if(not speed): self.__pos_y += MOVE_SPEED
|
|
else: self.__pos_y += speed[0]
|
|
if(self.__pos_y >= MAINSCREEN_SIZE[1]):
|
|
self.__pos_y = -self.__size_rect["y"]
|
|
|
|
elif(self.__movedirection['left']):
|
|
if(not speed): self.__pos_x -= MOVE_SPEED
|
|
else: self.__pos_x -= speed[0]
|
|
if(self.__pos_x <= -self.__size_rect["x"]):
|
|
self.__pos_x = MAINSCREEN_SIZE[0]
|
|
|
|
elif(self.__movedirection['right']):
|
|
if(not speed): self.__pos_x += MOVE_SPEED
|
|
else: self.__pos_x += speed[0]
|
|
if(self.__pos_x >= MAINSCREEN_SIZE[0]):
|
|
self.__pos_x = -self.__size_rect["x"]
|
|
|
|
|
|
#print("Objekt-Koordinaten "+self.__name+"= X: "+str(self.__rectobjekt.x)+" Y: "+str(self.__rectobjekt.y), end="\r")
|
|
|
|
def draw(self):
|
|
#font = pygame.font.SysFont(None, 70)
|
|
#text = font.render("TEST", True, (0,0,0) )
|
|
if(self.__hide == False): # Update this --redraw each 10 pixels or self_size
|
|
if(self.__is_player == True):
|
|
self.__updatepos(self.__pos_x, self.__pos_y)
|
|
self.__rectobjekt = pygame.draw.rect(self.__surface, self.__color, [self.__last_pos_x, self.__last_pos_y,self.__size_rect["x"],self.__size_rect["y"]])
|
|
else:
|
|
self.__rectobjekt = pygame.draw.rect(self.__surface, self.__color, [self.__pos_x, self.__pos_y,self.__size_rect["x"],self.__size_rect["y"]])
|
|
|
|
def get_position(self):
|
|
return (self.__pos_x, self.__pos_y)
|
|
|
|
def get_rect(self):
|
|
return self.__rectobjekt
|
|
|
|
def get_movespeed(self):
|
|
return self.__movespeed
|
|
|
|
def get_playermovedirection(self):
|
|
return self.__movedirection
|
|
|
|
def has_follower(self):
|
|
return self.__has_follower
|
|
|
|
def set_follower(self):
|
|
self.__has_follower = True
|
|
|
|
def __updatepos(self, posx, posy):
|
|
if posx == (self.__last_pos_x + self.__size_rect["x"]): self.__last_pos_x = self.__pos_x
|
|
if posy == (self.__last_pos_y + self.__size_rect["y"]): self.__last_pos_y = self.__pos_y
|
|
print("x= "+str(self.__last_pos_x)+" y= "+str(self.__last_pos_y), end="\r")
|
|
pass
|
|
|
|
def is_collided(self) -> bool:
|
|
return self.__collided
|
|
|
|
def set_collided(self):
|
|
self.__collided = True
|
|
|
|
def collide(self, GameObject):
|
|
#print(GameObject)
|
|
#print(GameObject.get_rect())
|
|
"""TODO: Hitbox with Objectsize"""
|
|
|
|
if(pygame.rect.Rect.colliderect(self.__rectobjekt, GameObject.get_rect()) and not self.is_collided()):
|
|
print("Kollision\n") #Funktioniert für das erste!
|
|
self.set_collided()
|
|
#self.hide() #Löscht das Objekt nach einem Zusammenstoß mit Playerobject
|
|
|
|
def hide(self):
|
|
if(self.__hide != True):
|
|
print("Gameoject mit der ID " + self.__name + " gelöscht!")
|
|
self.__hide = True
|
|
"""TODO: Delete obeject function"""
|
|
|
|
|
|
#print(pos)
|
|
#print(self.get_position())
|
|
|
|
|
|
class Playerfollower(GameObject):
|
|
def __init__(self, name: str, posx_init: int = 0, posy_init: int = 0, move_speed: int = 0, is_player: bool = False) -> None:
|
|
super().__init__(name, posx_init, posy_init, move_speed, is_player)
|
|
|
|
def start_game():
|
|
menu.disable()
|
|
return 0
|
|
|
|
def apply_name():
|
|
menu.disable()
|
|
#TODO: Add function for save name
|
|
pass
|
|
|
|
menu = pygame_menu.Menu("Snake v1.0", 400, 300,)
|
|
menu.add.text_input("Name: ", onreturn=apply_name)
|
|
menu.add.button('Play', start_game)
|
|
menu.add.button('Quit', pygame_menu.events.EXIT)
|
|
menu.mainloop(MAINSCREEN)
|
|
|
|
def spawn_entities(x:int):
|
|
Objects = list()
|
|
count = 0
|
|
for y in range(x):
|
|
Entity = GameObject("Entitiy-"+str(count), rand.randint(1,MAINSCREEN_SIZE[0]), rand.randint(1,MAINSCREEN_SIZE[1]), rand.randint(1,15))
|
|
Entity_rect = Entity.get_rect()
|
|
Objects.append(Entity)
|
|
count += 1
|
|
for x in Objects:
|
|
print(x)
|
|
return list(Objects)
|
|
|
|
"""def spawn_entities(x:int):
|
|
entity_count = x
|
|
count = 0
|
|
Objects = list()
|
|
print("Erstelle "+str(x)+" Objekte")
|
|
while(entity_count != 0):
|
|
Entity = GameObject("Entitiy-"+str(count), rand.randint(1,MAINSCREEN_SIZE[0]), rand.randint(1,MAINSCREEN_SIZE[1]), rand.randint(1,15))
|
|
Entity_pos = Entity.get_position()
|
|
|
|
if(count == 0):
|
|
Objects.append(Entity)
|
|
entity_count -= 1
|
|
print("Erstes Objekt erstellt")
|
|
else:
|
|
for x in Objects:
|
|
x:GameObject
|
|
#print(Entity_pos)
|
|
#print(x.get_position())
|
|
if(Entity_pos[0] <= (x.get_position()[0]-60) or Entity_pos[0] >= (x.get_position()[0] +60)):
|
|
if(Entity_pos[1] <= (x.get_position()[1]-60) or (Entity_pos[1] >= x.get_position()[1] +60)):
|
|
Objects.append(Entity)
|
|
entity_count -= 1
|
|
|
|
|
|
count += 1
|
|
print("Versuch: "+str(count), end="\r")
|
|
if(count == 20): break
|
|
|
|
return list(Objects)"""
|
|
|
|
|
|
|
|
|
|
Player = GameObject("Player", 10, 10, 10, is_player=False)
|
|
|
|
background = pygame.surface.Surface((640,480))
|
|
|
|
#Behandelt später die Hauptschleife und Klassenobjekte
|
|
class Game():
|
|
__state = {"win":False, "lose":False, "paused":False}
|
|
def __init__(self) -> None:
|
|
pass
|
|
|
|
class Follower(GameObject):
|
|
def __init__(self, name: str, posx_init: int = 0, posy_init: int = 0, move_speed: int = 0, is_player: bool = False) -> None:
|
|
super().__init__(name, posx_init, posy_init, move_speed, is_player)
|
|
|
|
def set_position(self, pos:tuple, playermovedirection:list):
|
|
|
|
if(playermovedirection["up"]):
|
|
self.__pos_y = pos[1]+60
|
|
self.__pos_x = pos[0]
|
|
if(playermovedirection["down"]):
|
|
self.__pos_y = pos[1]-60
|
|
self.__pos_x = pos[0]
|
|
if(playermovedirection["left"]):
|
|
self.__pos_x = pos[0]+60
|
|
self.__pos_y = pos[1]
|
|
if(playermovedirection["right"]):
|
|
self.__pos_x = pos[0]-60
|
|
self.__pos_y = pos[1]
|
|
|
|
x = 3600
|
|
invert = False
|
|
spawned_entities = spawn_entities(10) #Spawnt eine definierte Anzahl an GameObjekten
|
|
count_spawend_enities = len(spawned_entities)
|
|
test_grid_x = MAINSCREEN_SIZE[0]/60
|
|
colided_objects = list()
|
|
|
|
#Fenster-Hauptschleife
|
|
while active == True:
|
|
MAINSCREEN.fill((255,255,255))
|
|
for event in pygame.event.get():
|
|
if (event.type == pygame.QUIT):
|
|
print("Programm wird geschlossen!")
|
|
print(spawned_entities, end="\n")
|
|
active = False
|
|
elif (event.type == pygame.KEYDOWN):
|
|
if (event.key == pygame.K_UP):
|
|
print("Keydown")
|
|
Player.change_direction("up")
|
|
elif (event.key == pygame.K_DOWN):
|
|
print("Keydown")
|
|
Player.change_direction("down")
|
|
elif (event.key == pygame.K_RIGHT):
|
|
print("Keydown")
|
|
Player.change_direction("right")
|
|
elif (event.key == pygame.K_LEFT):
|
|
print("Keydown")
|
|
Player.change_direction("left")
|
|
|
|
Player.draw()
|
|
Player.move(5)
|
|
|
|
#Spawns the Entities
|
|
count_hidden_entities = 0
|
|
|
|
for y in spawned_entities:
|
|
y:GameObject
|
|
|
|
if(y.is_collided() == True):
|
|
#Der erste Follower folgt dem Spieler, alle übrigen folgen den vorherien Verfolgern
|
|
#y.hide()
|
|
count_hidden_entities += 1
|
|
colidedobj = Follower(y)
|
|
colided_objects.append(colidedobj)
|
|
spawned_entities.remove(y)
|
|
|
|
if(y.is_collided() == False):
|
|
y.draw()
|
|
y.collide(Player)
|
|
|
|
if(count_hidden_entities == count_spawend_enities):
|
|
print("WIN!!!")
|
|
menu.enable()
|
|
menu.add.label("WIN", "win", 10)
|
|
menu.mainloop(MAINSCREEN)
|
|
break
|
|
|
|
print(len(colided_objects))
|
|
obj1_count = 0
|
|
for obj1 in colided_objects:
|
|
obj1:Follower
|
|
Player:GameObject
|
|
print(Player.get_position())
|
|
obj1.set_position(Player.get_position(), Player.get_playermovedirection())
|
|
print(obj1.get_position())
|
|
#print(Player.get_playermovedirection())
|
|
obj1.draw()
|
|
"""Drawing Lines test
|
|
pos = 0
|
|
for x in range(20):
|
|
pos += 60
|
|
pygame.draw.line(MAINSCREEN, (0,0,0), (pos,0),(pos,MAINSCREEN_SIZE[1]))"""
|
|
|
|
if(x == 0):
|
|
for y in spawned_entities:
|
|
y.hide()
|
|
pass
|
|
x -= 1
|
|
|
|
#print("Objekt-Koordinaten= X: "+str(rect1.x)+" Y: "+str(rect1.y)+"", end="\r")
|
|
|
|
#Displayflip sorgt dafür, dass das Fenster entsprechend der Tickrate aktualisiert wird
|
|
#pygame.display.flip()
|
|
|
|
pygame.display.flip()
|
|
clock.tick(60)
|
|
pygame.quit() |