From 7ea8f8fd31c8a39876cf115cd168ba6654ec98c6 Mon Sep 17 00:00:00 2001
From: Leander <80996591+m0ntagur@users.noreply.github.com>
Date: Mon, 23 Jan 2023 15:31:30 +0100
Subject: Add files via upload

---
 Alien.py     |  27 +++++
 Bunker.py    |   9 ++
 Extra.py     |  18 ++++
 GUI.py       |  32 ++++++
 Laser.py     |  17 +++
 Spieler.py   |  51 +++++++++
 Steuerung.py |  62 +++++++++++
 Szenen.py    | 338 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 __init__.py  |   9 ++
 9 files changed, 563 insertions(+)
 create mode 100644 Alien.py
 create mode 100644 Bunker.py
 create mode 100644 Extra.py
 create mode 100644 GUI.py
 create mode 100644 Laser.py
 create mode 100644 Spieler.py
 create mode 100644 Steuerung.py
 create mode 100644 Szenen.py
 create mode 100644 __init__.py

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
-- 
cgit v1.3.1