Add files via upload

9 files changed, 563 insertions, 0 deletions

diff --git a/Alien.py b/Alien.py
new file mode 100644
index 0000000..5400447
--- /dev/null
+++ b/Alien.py
@@ -0,0 +1,27 @@
+import pygame

+import os

+

+class Alien(pygame.sprite.Sprite):

+  def __init__(self, bildDateipfad: str, position: tuple, wert: int):

+    super().__init__()

+    self.image = pygame.image.load(os.path.abspath(bildDateipfad))

+    self.rect = self.image.get_rect()

+    self.rect.center = position

+    

+    self.__wert = wert

+    self.__geschwindigkeit = 1

+  

+  def getRect(self):

+    return self.rect

+

+  def getWert(self) -> int:

+    return self.__wert

+  

+  def aendereRichtung(self):

+    self.__geschwindigkeit *= -1

+

+  def bewegen(self):

+    self.rect.x += self.__geschwindigkeit

+  

+  def bewegeRunter(self, y):

+    self.rect.y += y
\ No newline at end of file
diff --git a/Bunker.py b/Bunker.py
new file mode 100644
index 0000000..03cc2c7
--- /dev/null
+++ b/Bunker.py
@@ -0,0 +1,9 @@
+import pygame

+

+class Bunker(pygame.sprite.Sprite):

+  def __init__(self, x: int, y: int, groeße: int, farbe: tuple):

+    super().__init__()

+    self.image = pygame.Surface((groeße,groeße))

+    self.image.fill(farbe)

+    self.rect = self.image.get_rect()

+    self.rect.center = (x,y)
\ No newline at end of file
diff --git a/Extra.py b/Extra.py
new file mode 100644
index 0000000..edc60a3
--- /dev/null
+++ b/Extra.py
@@ -0,0 +1,18 @@
+import pygame

+import os

+

+class Extra(pygame.sprite.Sprite):

+  def __init__(self, x, y):

+    super().__init__()

+    self.image = pygame.image.load(os.path.abspath('assets/img/extra.png'))

+    self.rect = self.image.get_rect()

+    self.rect.center = (x,y)

+

+    self.__geschwindigkeit = 2

+  

+  def bewegen(self):

+    self.rect.x = self.rect.x + self.__geschwindigkeit

+  

+  def einschraenken(self, screenLaenge):

+    if self.rect.left >= screenLaenge:

+      self.kill()
\ No newline at end of file
diff --git a/GUI.py b/GUI.py
new file mode 100644
index 0000000..d1c6f96
--- /dev/null
+++ b/GUI.py
@@ -0,0 +1,32 @@
+import pygame

+import os

+

+class GUI():

+  def __init__(self, screen):

+    self.__screen = screen

+

+  def zeichneText(self, text: str, groeße: int, x: int, y: int, farbe: tuple):

+    font = pygame.font.Font(os.path.abspath('assets/8bit.ttf'), groeße)

+    text = font.render(text, True, farbe)

+    self.__screen.blit(text, (x-text.get_width()/2, y-text.get_height()/2))

+

+  def zeichneRoundedButton(self, text: str, groeße: int, x: int, y: int, weite: int, hoehe: int, radius: int, farbeButton: tuple, farbeText: tuple):

+

+    pygame.draw.aaline(self.__screen,farbeButton,(x-weite/2,y-hoehe/2+radius),(x-weite/2,y+hoehe/2-radius)) #left line

+    pygame.draw.aaline(self.__screen,farbeButton,(x+weite/2,y-hoehe/2+radius),(x+weite/2,y+hoehe/2-radius)) #right line

+    pygame.draw.aaline(self.__screen,farbeButton,(x-weite/2+radius,y-hoehe/2),(x+weite/2-radius,y-hoehe/2)) #top line

+    pygame.draw.aaline(self.__screen,farbeButton,(x-weite/2+radius,y+hoehe/2),(x+weite/2-radius,y+hoehe/2)) #bottom line

+

+    pygame.draw.circle(self.__screen,farbeButton,(x-weite/2+radius,y-hoehe/2+radius),radius, 0) #topleft circle

+    pygame.draw.circle(self.__screen,farbeButton,(x+weite/2-radius,y-hoehe/2+radius),radius, 0) #topright circle

+    pygame.draw.circle(self.__screen,farbeButton,(x-weite/2+radius,y+hoehe/2-radius),radius, 0) #bottomleft circle

+    pygame.draw.circle(self.__screen,farbeButton,(x+weite/2-radius,y+hoehe/2-radius),radius, 0) #bottomright circle

+

+    pygame.draw.rect(self.__screen, farbeButton, pygame.Rect(x-weite/2+radius,y-hoehe/2,weite-radius*2,hoehe)) #middle rect

+    pygame.draw.rect(self.__screen, farbeButton, pygame.Rect(x-weite/2,y-hoehe/2+radius,radius,hoehe-radius*2)) #left rect

+    pygame.draw.rect(self.__screen, farbeButton, pygame.Rect(x+weite/2-radius,y-hoehe/2+radius,radius,hoehe-radius*2)) #right rect

+

+    font = pygame.font.Font(os.path.abspath('assets/8bit.ttf'), groeße)

+    text = font.render(text, True, farbeText)

+    self.__screen.blit(text, (x-text.get_width()/2, y-text.get_height()/2))

+    

diff --git a/Laser.py b/Laser.py
new file mode 100644
index 0000000..18503d0
--- /dev/null
+++ b/Laser.py
@@ -0,0 +1,17 @@
+import pygame

+

+class Laser(pygame.sprite.Sprite):

+  def __init__(self, position: tuple, geschwindigkeit: str):

+    super().__init__()

+    self.image = pygame.Surface((3,10))

+    self.image.fill((255,255,255)) # Farbe

+    self.rect = self.image.get_rect()

+    self.rect.center = position

+    

+    self.__geschwindigkeit = geschwindigkeit

+

+  def getRect(self):

+    return self.rect

+

+  def bewegen(self):

+    self.rect.y += self.__geschwindigkeit
\ No newline at end of file
diff --git a/Spieler.py b/Spieler.py
new file mode 100644
index 0000000..0c2f362
--- /dev/null
+++ b/Spieler.py
@@ -0,0 +1,51 @@
+import pygame

+import os

+

+class Spieler(pygame.sprite.Sprite):

+  def __init__(self, position: tuple):

+    super().__init__()

+    self.image = pygame.image.load(os.path.abspath('assets/img/player.png'))

+    self.rect = self.image.get_rect()

+    self.rect.center = position

+

+    self.__leben = 3

+    self.__geschwindigkeit = 8

+

+    self.__laserCoolDown = 300

+    self.__zeitVonLetzenSchuss = 0

+  

+  def getLaserPostion(self) -> tuple:

+    return (self.rect.centerx, self.rect.top)

+

+  def getLeben(self) -> int:

+    return self.__leben

+

+  def bewegen(self):

+    keys = pygame.key.get_pressed()

+    if keys[pygame.K_LEFT]:

+      self.rect.x -= self.__geschwindigkeit

+    if keys[pygame.K_RIGHT]:

+      self.rect.x += self.__geschwindigkeit

+  

+  def einschraenken(self, screenLaenge):

+    if self.rect.left <= 0:

+      self.rect.x = 0

+    if self.rect.right >= screenLaenge:

+      self.rect.right = screenLaenge

+  

+  def schuss(self):

+    keys = pygame.key.get_pressed()

+    jetzt = pygame.time.get_ticks()

+    if keys[pygame.K_SPACE] and jetzt - self.__zeitVonLetzenSchuss >= self.__laserCoolDown:

+      self.__zeitVonLetzenSchuss = jetzt

+      return True

+    else:

+      return False

+

+  def treffer(self):

+    self.__leben -= 1

+

+  def heilen(self):

+    self.__leben += 1

+  

+

diff --git a/Steuerung.py b/Steuerung.py
new file mode 100644
index 0000000..7f0a592
--- /dev/null
+++ b/Steuerung.py
@@ -0,0 +1,62 @@
+import pygame

+from Szenen import *

+

+class Steuerung():

+  def __init__(self):

+    self.__szene = Menue()

+    self.__szenenIndex = 0

+    self.__verlasseSpiel = False

+    self.__spielerListe = []

+    self.__loop()

+

+  def __sotiereSpielerListe(self):

+    self.__spielerListe.sort(key=lambda spieler: spieler[1], reverse=True)

+

+  def __addSpieler(self, spielerName: str, spielerScore: int):

+    gibtSpieler = False

+    for spieler in range(len(self.__spielerListe)):

+      if self.__spielerListe[spieler][0] == spielerName:

+        gibtSpieler = True

+        self.__spielerListe[spieler][1] = spielerScore

+    if not gibtSpieler:

+      self.__spielerListe.append((spielerName, spielerScore))

+

+  def __verlasseSpiel(self):

+    self.__verlasseSpiel = True

+

+  def __wechselSzene(self):

+    self.__szenenIndex += 1

+    if self.__szenenIndex > 3:

+      self.__szenenIndex = 0

+    match(self.__szenenIndex):

+      case 0:

+        self.__szene = Menue()

+      case 1:

+        self.__szene = Game()

+      case 2:

+        score = self.__szene.getScore()

+        self.__szene = Benennung(score)

+      case 3:

+        score = self.__szene.getScore()

+        name = self.__szene.getName()

+        self.__addSpieler(name, score)

+        self.__sotiereSpielerListe()

+        self.__szene = Score(self.__spielerListe)

+

+

+  def __loop(self):  

+    while not self.__szene == None and not self.__verlasseSpiel:

+      events = []

+      for event in pygame.event.get():

+        if event.type == pygame.QUIT:

+          self.__verlasseSpiel = True

+        if event.type == pygame.KEYDOWN:

+          events.append(event)

+          self.__szene.beiEingabe(events)

+

+      self.__szene.beiUpdate()

+

+      self.__szene.beiZeichne()

+

+      if self.__szene.getWechselSzene():

+        self.__wechselSzene()
\ No newline at end of file
diff --git a/Szenen.py b/Szenen.py
new file mode 100644
index 0000000..58b139d
--- /dev/null
+++ b/Szenen.py
@@ -0,0 +1,338 @@
+import pygame

+

+class Szene():

+  def __init__(self):

+    self._wechselSzene = False

+

+  def beiEingabe(self, events: list):

+    pass

+

+  def beiUpdate(self):

+    pass

+  

+  def beiZeichne(self):

+    pass

+  

+  def getWechselSzene(self):

+    return self._wechselSzene

+

+from GUI import GUI

+

+class Menue(Szene):

+  def __init__(self, ):

+    super().__init__()

+    self.__screen = pygame.display.set_mode((600,700))

+    pygame.display.set_caption('Space Invaders')

+    self.__dieGUI = GUI(self.__screen)

+

+    self.__background = pygame.Surface((self.__screen.get_width(), self.__screen.get_height()))

+    self.__background.fill((0,0,0))

+

+  def beiEingabe(self, events: list):

+    # Alle Tasten werden in eine Liste gespeichert, wenn eine Taste gedrueckt ist der Wert des Index der Taste 1

+    keys = pygame.key.get_pressed()

+    # Wenn die Leertaste gedrueckt ist starte das Spiel

+    if keys[pygame.K_SPACE]:

+      self._wechselSzene = True

+

+  def beiZeichne(self):

+    # Der Hintergrund wird auf den Screen gezeichnet

+    self.__screen.blit(self.__background, (0,0))

+

+    self.__dieGUI.zeichneText('Space Invaders', 20, self.__screen.get_width()/2, self.__screen.get_height()*0.20, (255,255,255))

+    self.__dieGUI.zeichneText('Um das Spiel zu starten druecke:', 16, self.__screen.get_width()/2, self.__screen.get_height()*0.40, (255,255,255))

+    self.__dieGUI.zeichneRoundedButton('Space', 15,self.__screen.get_width()/2, self.__screen.get_height()*0.60, 120, 60, 10, (255,255,255), (0,0,0))

+    

+    # Das Bild wird refreshed

+    pygame.display.flip()

+

+from random import randrange

+from Extra import Extra

+from Bunker import Bunker

+from Laser import Laser

+from Spieler import Spieler

+from Alien import Alien

+

+class Game(Szene):

+  def __init__(self):

+    super().__init__()

+    self.__screen = pygame.display.set_mode((600,700))

+    self.__clock = pygame.time.Clock()

+

+    self.__hintergrund = pygame.Surface((self.__screen.get_width(), self.__screen.get_height()))

+    self.__hintergrund.fill((0,0,0))

+

+    self.__score = 0

+    self.__alienUebrig = 0

+    self.__alienSchussIntervall = 1000

+    self.__zeitVonLetztenAlienSchuss = 0

+

+    self.__extraSpawnIntervall = 40000

+    self.__zeitvonLetztenExtra = 1

+

+    self.__volume = 0.1

+    self.__shootSound = pygame.mixer.Sound('assets/sound/shoot.wav')

+    self.__shootSound.set_volume(self.__volume)

+    self.__alienTodSound = pygame.mixer.Sound('assets/sound/invaderkilled.wav')

+    self.__alienTodSound.set_volume(self.__volume)

+    self.__spielerTodSound = pygame.mixer.Sound('assets/sound/explosion.wav')

+    self.__spielerTodSound.set_volume(self.__volume)

+

+    self.__derSpieler = Spieler((self.__screen.get_width()/2, self.__screen.get_height()*0.90))

+

+    self.__dieGUI = GUI(self.__screen)

+    self.__spielerSpriteGruppe = pygame.sprite.GroupSingle(self.__derSpieler)

+    self.__spielerLaserSpriteGruppe = pygame.sprite.Group()

+    self.__alienSpriteGruppe = pygame.sprite.Group()

+    self.__alienLaserSpriteGruppe = pygame.sprite.Group()

+    self.__extraSpriteGruppe = pygame.sprite.GroupSingle()

+    self.__bunkerSpriteGruppe = pygame.sprite.Group()

+

+    self.__bunkerForm = [

+    '  xxxxxxx',

+    ' xxxxxxxxx',

+    'xxxxxxxxxxx',

+    'xxxxxxxxxxx',

+    'xxx     xxx',

+    'xx       xx',

+    ]

+

+    self.__erstelleAlleBunker(anzahl=4,groeße=7,startX=50,startY=self.__screen.get_width()*0.85, xOffset=80)

+    self.__erstelleAliens(zeilen=6,spalten=8,startX=50, startY=100,xDistanz=20,yDistanz=20)

+

+  def __erstelleBunker(self, groeße: int, startX: int, startY: int):

+    for zeile in range(len(self.__bunkerForm)):

+      for spalte in range(len(self.__bunkerForm[zeile])):

+        if self.__bunkerForm[zeile][spalte] == 'x':

+          x = startX + spalte * groeße

+          y = startY + zeile * groeße

+          derBlock = Bunker(x, y, groeße, (180,70,60))

+          self.__bunkerSpriteGruppe.add(derBlock)

+

+  def __erstelleAlleBunker(self, anzahl: int, groeße: int, startX: int, startY: int, xOffset: int):

+    for spalte in range(anzahl):

+      x = startX + (spalte * len(self.__bunkerForm[0]) * groeße) + (spalte * xOffset)

+      y = startY

+      self.__erstelleBunker(groeße,x,y)

+

+  def __erstelleAliens(self, zeilen: int, spalten: int, startX: int, startY: int, xDistanz: int, yDistanz: int):

+      beispielAlien = pygame.image.load('assets/img/red.png')

+      weiteAlien = beispielAlien.get_width()

+      hoeheAlien = beispielAlien.get_height()

+      

+      for zeile in range(zeilen):

+        for spalte in range(spalten):

+          x = startX + spalte *  weiteAlien + spalte * xDistanz

+          y = startY + zeile * hoeheAlien + zeile * yDistanz

+          if zeile == 0:

+            dasAlien = Alien('assets/img/yellow.png', (x, y), 60)

+          elif zeile == 1 or zeile == 2:

+            dasAlien = Alien('assets/img/green.png', (x, y), 30)

+          elif zeile == 3 or zeile == 4 or zeile == 5:

+            dasAlien = Alien('assets/img/red.png', (x, y), 20)

+          self.__alienSpriteGruppe.add(dasAlien)

+  

+  def __bewegeAliens(self):

+    for alien in self.__alienSpriteGruppe:

+      alien.bewegen()

+      if alien.getRect().right >= self.__screen.get_width():

+        for alien in self.__alienSpriteGruppe:

+          alien.aendereRichtung()

+          alien.bewegeRunter(12)

+      elif alien.getRect().left <= 0:

+        for alien in self.__alienSpriteGruppe:

+          alien.aendereRichtung()

+          alien.bewegeRunter(12)

+  

+  def __alienSchuss(self):

+    jetzt = pygame.time.get_ticks()

+    if jetzt - self.__zeitVonLetztenAlienSchuss >= self.__alienSchussIntervall and len(self.__alienSpriteGruppe) > 0:

+      alienListe = list(self.__alienSpriteGruppe)

+      randomAlien = alienListe[randrange(len(alienListe))]

+      self.__zeitVonLetztenAlienSchuss = pygame.time.get_ticks()

+      self.__shootSound.play()

+      self.__alienLaserSpriteGruppe.add(Laser((randomAlien.getRect().centerx, randomAlien.getRect().bottom), 2))

+

+  def __erstelleExtra(self):

+    jetzt = pygame.time.get_ticks()

+    if jetzt - self.__zeitvonLetztenExtra >= self.__extraSpawnIntervall:

+      self.__extraSpriteGruppe.add(Extra(-10, 50))

+      self.__zeitvonLetztenExtra = jetzt

+  

+  def __bewegeExtra(self):

+    for extra in self.__extraSpriteGruppe:

+      extra.bewegen()

+      extra.einschraenken(self.__screen.get_width())

+

+  def __kollision(self):

+    for laser in self.__alienLaserSpriteGruppe:

+      # Wenn ein Laser von Alien Bunker soll der Laser und ein Teil des Bunker zerstört werden

+      if pygame.sprite.spritecollide(laser,self.__bunkerSpriteGruppe,True):

+        laser.kill()

+

+      # Wenn ein Laser von einem Alien den Spieler trifft soll das Sprite vom Spieler nicht zerstört

+      # werden der Laser schon und ein Leben des Spieler wird abgezogen

+      if pygame.sprite.spritecollide(laser,self.__spielerSpriteGruppe,False):

+        laser.kill()

+        self.__derSpieler.treffer()

+        if self.__derSpieler.getLeben() == 0:

+          # Wenn der Spieler keine Leben hat Sound abspielen und zur nächsten Szene wechseln

+          self.__spielerTodSound.play()

+          self._wechselSzene = True

+

+    for alien in self.__alienSpriteGruppe:

+      # Wenn ein Alien einen Bunker berührt hat der Spieler es nicht geschaft die Welt zu beschützen

+      if pygame.sprite.spritecollide(alien,self.__bunkerSpriteGruppe,False):

+        self._wechselSzene = True

+

+    for laser in self.__spielerLaserSpriteGruppe:

+      # Wenn ein Laser vom Spieler, den Bunker trifft, soll nur der Laser zerstört werden

+      if pygame.sprite.spritecollide(laser,self.__bunkerSpriteGruppe,False):

+        laser.kill()

+      

+      # Wenn der Spieler das extra Leben trifft, soll der Laser zerstört und der Spieler geheilt werden

+      if pygame.sprite.spritecollide(laser,self.__extraSpriteGruppe,True):

+        self.__derSpieler.heilen()

+        laser.kill()

+

+      # Wenn ein Laser vom Spieler ein Alien trifft, soll das Alien und der Laser zerstört werden

+      if pygame.sprite.spritecollide(laser,self.__alienSpriteGruppe,False):

+        # Alle Alien die den Laser berühren werden in eine Liste gespeichert

+        kollidierteAliens = pygame.sprite.spritecollide(laser,self.__alienSpriteGruppe,False)

+        # ...

+        for alien in kollidierteAliens:

+          # Der Wert des Alien wird dem Score hinzugefügt

+          self.__score += alien.getWert()

+          # Lade und spiele Sound ab

+          self.__alienTodSound.play()

+          alien.kill()

+        laser.kill()

+

+      # Wenn ein Laser vom Spieler mit einem Laser vom Alien trifft, sollen beide zerstört werden

+      if pygame.sprite.spritecollide(laser,self.__alienLaserSpriteGruppe,True):

+        laser.kill()

+

+  def getScore(self):

+    return self.__score

+

+  def beiUpdate(self):

+    

+    if self.__derSpieler.schuss():

+      self.__spielerLaserSpriteGruppe.add(Laser(self.__derSpieler.getLaserPostion(), -10))

+      self.__shootSound.play()

+    

+    self.__derSpieler.bewegen()

+    self.__derSpieler.einschraenken(screenLaenge=self.__screen.get_width())

+

+    self.__alienSchuss()

+    self.__bewegeAliens()

+

+    for laser in self.__alienLaserSpriteGruppe:

+      laser.bewegen()

+    for laser in self.__spielerLaserSpriteGruppe:

+      laser.bewegen()

+    

+    self.__kollision()

+    self.__alienUebrig = len(self.__alienSpriteGruppe)

+

+    self.__erstelleExtra()

+    self.__bewegeExtra()

+

+    if self.__alienUebrig <= 0:

+      self.__erstelleAliens(zeilen=6,spalten=8,startX=50, startY=100,xDistanz=20,yDistanz=20)

+

+    self.__clock.tick(60)

+  

+  def beiZeichne(self):

+    self.__screen.blit(self.__hintergrund, (0,0))

+

+    self.__spielerSpriteGruppe.draw(self.__screen)

+    self.__spielerLaserSpriteGruppe.draw(self.__screen)

+

+    self.__alienSpriteGruppe.draw(self.__screen)

+    self.__alienLaserSpriteGruppe.draw(self.__screen)

+

+    self.__extraSpriteGruppe.draw(self.__screen)

+

+    self.__bunkerSpriteGruppe.draw(self.__screen)

+

+    self.__dieGUI.zeichneText(f'Score: {self.__score}', 12, 100, self.__screen.get_height()*0.05, (255,255,255))

+    self.__dieGUI.zeichneText(f'Leben: {self.__derSpieler.getLeben()}', 12, self.__screen.get_width()-100, self.__screen.get_height()*0.05, (255,255,255))

+    pygame.display.flip()

+

+class Benennung(Szene):

+  def __init__(self, score: int):

+    super().__init__()

+    self.__screen = pygame.display.set_mode((600,800))

+    self.__clock = pygame.time.Clock()

+    

+    self.__hintergrund = pygame.Surface((self.__screen.get_width(), self.__screen.get_height()))

+    self.__hintergrund.fill((0,0,0))

+

+    self.__score = score

+    self.__spielerName = ''

+

+    self.__dieGUI = GUI(self.__screen)

+

+  def getName(self):

+    return self.__spielerName

+  

+  def getScore(self):

+    return self.__score

+

+  def beiEingabe(self, events: list):

+    for event in events:

+      if event.key == pygame.K_BACKSPACE:

+        # Das letzte Zeichen (-1) wird weg gelassen/gelöscht

+        self.__spielerName = self.__spielerName[:-1]

+      

+      elif event.key == pygame.K_RETURN and len(self.__spielerName) > 0:

+        self._wechselSzene = True

+

+      elif event.unicode != ' ' and not len(self.__spielerName) > 3:

+        # Limitiere Spielername auf 3 Zeichen

+        self.__spielerName += event.unicode

+

+  def beiUpdate(self):

+    pass

+

+  def beiZeichne(self):

+    

+    self.__screen.blit(self.__hintergrund, (0,0))

+

+    self.__dieGUI.zeichneText(f'Bitte geben sie ihren Name ein!', 12, self.__screen.get_width()/2, self.__screen.get_height()/2-50, (255,255,255))

+    self.__dieGUI.zeichneText(f'{self.__spielerName} : {self.__score}', 12, self.__screen.get_width()/2, self.__screen.get_height()/2, (255,255,255))

+

+    self.__clock.tick(999)

+

+    pygame.display.flip()

+

+class Score(Szene):

+  def __init__(self, spielerListe):

+    super().__init__()

+    self.__screen = pygame.display.set_mode((600,700))

+    self.__spielerListe = spielerListe

+    self.__dieGUI = GUI(self.__screen)

+

+    self.__zeichneHighScoreListe(self.__screen.get_width()/2, 100, 50)

+

+    pygame.display.flip()

+

+  def __zeichneHighScoreListe(self, startPosX, startPosY, offsetY):

+    x = startPosX

+    y = startPosY

+    for i in range(9):

+      if not i == 0:

+        y += offsetY

+

+      if len(self.__spielerListe)-1 >= i:

+        self.__dieGUI.zeichneText(f'{i+1}. {self.__spielerListe[i][0]} : {self.__spielerListe[i][1]}', 12, x, y, (255,255,255))

+      else:

+        self.__dieGUI.zeichneText(f'{i+1}. ___ : ___', 12, x, y, (255,255,255))

+    

+    self.__dieGUI.zeichneRoundedButton('Retry Press Space', 8, self.__screen.get_width()/2, self.__screen.get_height()-30, 180, 20, 5, (255,255,255), (0,0,0))

+  

+  def beiEingabe(self, events: list):

+    for event in events:

+      if event.key == pygame.K_SPACE:

+        self._wechselSzene = True
\ No newline at end of file
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000..adf7a03
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1,9 @@
+import pygame

+from Steuerung import Steuerung

+

+pygame.init() 

+

+dieSteuerung = Steuerung()

+dieSteuerung.loop()

+

+pygame.quit()
\ No newline at end of file