testt

01/Zahlenraten.py

@@ -0,0 +1,22 @@
+from random import*
+
+zufallszahl = randint(0, 20)
+
+eingabe = int(input("Gesucht ist eine Zahl zwischen 0 und 20. Welche? "))
+
+versuche = 1
+
+while eingabe != zufallszahl:
+    
+
+    if eingabe < zufallszahl:
+        eingabe = int(input("Zu Klein, erneut versuchen: "))
+
+    if eingabe > zufallszahl:
+        eingabe = int(input("Zu groß, erneut versuchen: "))
+
+    versuche = versuche + 1  
+    
+print("Super, Sie haben es innerhalb von",
+versuche, "Versuchen geschafft!")
+

01/galgenmaennchen.py

@@ -0,0 +1,38 @@
+name = input("Wie heißt Du? ")
+
+print ("Hallo, " + name, "lass uns Galgenmännchen spielen!")
+print("Die Striche stehen für jeweils für einen Buchstaben.")
+
+wort = "test123"
+versuche = ''
+durchlauf = 10
+
+while durchlauf > 0:         
+    fehlversuche = 0             
+
+    for char in wort:      
+        if char in versuche:    
+            print(char)    
+        else:
+            print("_")     
+            fehlversuche += 1                
+
+    if fehlversuche == 0:
+        print(f"Gewonnen! Glückwunsch {name} das Wort war {wort}!")
+        break
+
+    versuch = input("Gib einen Buchstaben ein:") 
+
+    versuche += versuch[0].lower()          
+
+    if versuch not in wort:  
+        durchlauf -= 1        
+        print ("Falsch")
+  
+        print ("Du hast", + durchlauf, 'weitere Versuche') 
+ 
+        if durchlauf == 0:           
+            print("Verloren")
+
+
+

02/Praktikum 3.py

@@ -0,0 +1,162 @@
+
+# 1.
+
+sternchen = "***"
+leer = " "
+
+for _ in range(7):
+    print(sternchen)
+    sternchen = leer + sternchen
+
+
+2.
+
+#Aufgabe: Wo ist der Fehler?
+
+# zahl = int(input("Geben Sie eine Zahl ein: "))
+# int(zahl)
+# if (zahl > 5):
+#     print("größer 5")
+
+
+# 3.
+
+# print("Wilkommen. Geben sie Zahlen zum Addieren ein. Mit 0 beeneden sie die Eingabe")
+# ges = 0
+# while True:
+#     wert = int(input("Wert: "))
+#     ges = ges + wert
+#     if wert == 0:
+#         print(f"Zusammen ergibt das: {ges}")
+#         break
+
+
+# 4.
+
+# zahlenfolge = []
+# print("Wilkommen, bitte geben sie Zahlen fpr die Zahlenfolge ein!")
+# while True:
+#     wert = int(input("Wert: "))
+
+#     if wert == 0:
+#         zahlenfolge.reverse()
+#         print(zahlenfolge)
+#         break
+
+#     zahlenfolge.append(wert)
+
+# oder, nicht als liste ausgegeben
+
+# zahlenfolge = []
+# print("Wilkommen, bitte geben sie Zahlen fpr die Zahlenfolge ein!")
+# while True:
+#     wert = int(input("Wert: "))
+
+#     if wert == 0:
+#         for entry in zahlenfolge[::-1]:
+#             print(entry)
+
+#     zahlenfolge.append(wert)
+
+# 5.
+
+# zahlen = []
+# ges = 0
+# print("Bitte geben sie Zahlen zum Addieren ein, jede Zahl wird nur einmal berücksichtigt. 0 Um das Program zu beenden.")
+
+# while True:
+#     wert = int(input("Zahl: "))
+#     if wert in zahlen:
+#         print("Wert bereits eingegeben")
+#     if wert not in zahlen:
+#         zahlen.append(wert)
+#     if wert == 0:
+#         for entry in zahlen:
+#             ges = ges + entry
+#         print(f"Abbruch erfolgreich, Gesamt: {ges}")
+#         break
+
+
+# 6.
+
+o_banner = (" *** ",
+            "*   *",
+            "*   *",
+            "*   *",
+            " *** ")
+
+h_banner = ("*   *",
+            "*   *",
+            "*****",
+            "*   *",
+            "*   *",)
+
+m_banner = ("*   *",
+            "** **",
+            "* * *",
+            "*   *",
+            "*   *",)
+
+banner1 = []
+banner2 = []
+banner3 = []
+banner4 = []
+banner5 = []
+ges = []
+
+
+eing = str(input("Bitte geben sie einen Banner ein: "))
+eing = eing.lower()
+
+for entry in eing:
+
+    if entry == "o":
+        banner1.append(o_banner[0])
+        banner2.append(o_banner[1])
+        banner3.append(o_banner[2])
+        banner4.append(o_banner[3])
+        banner5.append(o_banner[4])
+
+    if entry == "h":
+        banner1.append(h_banner[0])
+        banner2.append(h_banner[1])
+        banner3.append(h_banner[2])
+        banner4.append(h_banner[3])
+        banner5.append(h_banner[4])
+
+    if entry == "m":
+        banner1.append(m_banner[0])
+        banner2.append(m_banner[1])
+        banner3.append(m_banner[2])
+        banner4.append(m_banner[3])
+        banner5.append(m_banner[4])
+
+
+ges = [banner1, banner2, banner3, banner4, banner5]
+
+for ent in ges:
+    print(*ent)
+
+
+# oder mit dictionary und += um 5 einträge mit jeweils einem sting zu bekommen, die siche ifnacher drucken lassen und um die leerzeichen einfacher einzufügen
+
+# banners = {
+#     "o": o_banner,
+#     "h": h_banner,
+#     "m": m_banner
+# }
+
+# word = input("Geben Sie ein Wort ein: ").lower()
+
+# result = [""] * 5
+
+# for character in word:
+#     if character in banners:
+#         banner = banners[character]
+
+#         for i in range(5):
+#             result[i] += banner[i] + "  " 
+
+# for zeile in result:
+#     print(zeile)
+

03/Aufgabe 1.py

@@ -0,0 +1,11 @@
+#Definition 1
+
+def fakultaet_iterativ(n):
+    fak = 1
+    for a in range(1, n+1):
+        fak = fak * a
+    print(fak)
+
+
+fakultaet_iterativ(4)
+# fakultaet_iterativ(10000)

03/Aufgabe 1b.py

@@ -0,0 +1,14 @@
+
+
+def fakultaet_rekursiv(n):
+    
+    b = 1
+
+    if n == 0:
+        return 1
+    
+    else:
+        return n * fakultaet_rekursiv(n - 1)
+
+print(fakultaet_rekursiv(4))
+#print(fakultaet_rekursiv(10000))

03/Aufgabe2a.py

@@ -0,0 +1,22 @@
+
+
+def ist_enthalten(n, z):
+    if len(z) == 0:
+        return False
+
+    m = len(z) // 2
+
+    if z[m] == n:
+        return True
+    elif z[m] < n:
+        return ist_enthalten(n, z[m+1:])   # Obere Hälfte der Liste
+    elif z[m] > n:
+        return ist_enthalten(n, z[:m])     # Untere Hälfte der Liste
+
+
+z = [1,2,3,5,8,13,21,34]
+print(ist_enthalten(7, z))
+print(ist_enthalten(5, z))
+print(ist_enthalten(60, z))
+
+#maximal 4 iterationen

03/Aufgabe2b.py

@@ -0,0 +1,23 @@
+
+
+def ist_enthalten(n, z):
+
+    i = 0
+    
+    while i < len(z):
+
+        m = z[i]
+
+        if m == n:
+            return True
+        else:
+            i += 1
+            
+    return False
+
+
+
+z = [1,2,3,5,8,13,21,34]
+print(ist_enthalten(7, z))
+print(ist_enthalten(5, z))
+print(ist_enthalten(60, z))

03/TurtleA2.py

@@ -0,0 +1,8 @@
+import math
+
+wand = 200
+diag = math.sqrt(wand**2+wand**2)
+dach = math.sqrt((wand/2)**2+(wand/2)**2)
+
+print(f"{diag:.2f}")
+print(f"{dach:.2f}")

03/TurtleA3.py

@@ -0,0 +1,65 @@
+import turtle as t
+import math
+
+wand = 200
+diag = math.sqrt(wand**2+wand**2)
+dach = math.sqrt((wand/2)**2+(wand/2)**2)
+tuer_breite = 20
+tuer_hoehe = 40
+fenster_r = 20 # Radius
+
+
+pen = t.Pen()
+pen.color("red")
+
+#Haus vom Nikolaus
+pen.up()
+pen.forward(-wand//2)
+pen.left(90)
+pen.down()             #anfangen
+pen.forward(wand)
+pen.right(45)
+pen.forward(dach)
+pen.right(90)
+pen.forward(dach)
+pen.right(135)
+pen.forward(wand)
+pen.left(135)
+pen.forward(diag)
+pen.right(135)
+pen.forward(wand)
+pen.right(135)
+pen.forward(diag)
+pen.right(135)
+pen.forward(wand)
+pen.up()
+
+#Tür
+pen.home()
+pen.forward(-tuer_breite/2)
+pen.left(90)
+pen.fillcolor("blue")
+pen.begin_fill()
+pen.forward(tuer_hoehe)
+pen.right(90)
+pen.forward(tuer_breite)
+pen.right(90)
+pen.forward(tuer_hoehe)
+pen.right(90)
+pen.forward(tuer_breite)
+pen.right(90)
+pen.end_fill()
+
+#Fenster
+
+pen.home()
+pen.left(90)
+pen.forward(wand + wand//4)
+pen.right(90)
+pen.forward(fenster_r)
+pen.left(90)
+pen.begin_fill()
+pen.circle(fenster_r)
+pen.end_fill()
+
+t.done()

04/karte.py

@@ -0,0 +1,112 @@
+
+connections = [('Würzburg', 'Schweinfurt', 50),
+             ('Würzburg', 'Nürnberg', 100),
+             ('Schweinfurt', 'Bamberg', 60),
+             ('Bamberg', 'Coburg', 50),
+             ('Bamberg', 'Nürnberg', 60),
+             ('Bamberg', 'Bayreuth', 60),
+             ('Nürnberg', 'Bayreuth', 90),
+             ('Bayreuth', 'Hof', 50),
+             ('Coburg', 'Hof', 80),
+            ]
+
+def allNodes(connections):
+    nodes = set()
+
+    for a in connections:
+        nodes.add(a[0])
+        nodes.add(a[1])
+    
+    return nodes
+
+def initMap(connections):
+
+    m = allNodes(connections)
+    knoten = {}
+    
+    for a in m:
+        knoten[a] = {}
+    
+    return knoten
+
+def addConnection(data, connection):
+    a, b, c = connection
+
+    data[a].setdefault('connection', []).append([b, c])
+    data[b].setdefault('connection', []).append([a, c])
+
+    return data
+
+def resetMap(map):
+    for node in map:
+        map[node]["distance"] = None
+        map[node]["predecessor"] = None
+        map[node]["finalized"] = False
+
+def setStart(map, start):
+    resetMap(map)
+    map[start]["distance"] = 0
+    map[start]["predecessor"] = start
+    map[start]["finalized"] = False
+
+    return map
+
+
+def calculateAllDistances(map: dict):
+
+
+    while True:
+        knoten = None
+        dist = None
+
+        for stadt in map:
+            if map[stadt]["finalized"] == False and map[stadt]["distance"] is not None:
+                if dist is None or map[stadt]["distance"] < dist:
+                    knoten = stadt
+                    dist = map[stadt]["distance"]
+
+        if knoten == None:
+            break
+        
+        map[knoten]["finalized"] = True
+
+        for verbindung in map[knoten]["connection"]:
+            zielstadt = verbindung[0]
+            entfernung = verbindung[1]
+
+            neue_entfernung = map[knoten]["distance"] + entfernung
+
+            if map[zielstadt]["distance"] is None or neue_entfernung < map[zielstadt]["distance"]:
+                map[zielstadt]["distance"] = neue_entfernung
+                map[zielstadt]["predecessor"] = knoten
+
+    return map
+
+        
+def pathFromTo(map, start, ende):
+    path = []
+
+    aktuelle_stadt = ende
+
+    while True:
+        path.insert(0, aktuelle_stadt)
+
+        if aktuelle_stadt == start:
+            break
+
+        aktuelle_stadt = map[aktuelle_stadt]["predecessor"]
+
+    return path
+
+
+    
+map = initMap(connections)
+# print(initMap(connections))
+# print(connections[0][0])
+for con in connections:
+    addConnection(map, con)
+# print(map)
+setStart(map, "Würzburg")
+calculateAllDistances(map)
+print(calculateAllDistances(map))
+print(pathFromTo(map, "Würzburg", "Hof"))

04/test

@@ -0,0 +1,49 @@
+
+connections = [('Würzburg', 'Schweinfurt', 50),
+             ('Würzburg', 'Nürnberg', 100),
+             ('Schweinfurt', 'Bamberg', 60),
+             ('Bamberg', 'Coburg', 50),
+             ('Bamberg', 'Nürnberg', 60),
+             ('Bamberg', 'Bayreuth', 60),
+             ('Nürnberg', 'Bayreuth', 90),
+             ('Bayreuth', 'Hof', 50),
+             ('Coburg', 'Hof', 80),
+            ]
+
+def allNodes(connections):
+    nodes = set()
+
+    for a in connections:
+        nodes.add(a[0])
+        nodes.add(a[1])
+    
+    return nodes
+
+def initMap(connections):
+
+    m = allNodes(connections)
+    knoten = {}
+    
+    for a in m:
+        knoten[a] = {}
+    
+    return knoten
+
+def addConnection(data, connection):
+    a, b, c = connection
+
+    data[a].setdefault('connection', []).append([b, c])
+    data[b].setdefault('connection', []).append([a, c])
+
+    return data
+
+
+
+    
+map = initMap(connections)
+print(initMap(connections))
+print(connections[0][0])
+for con in connections:
+    addConnection(map, con)
+print(map)
+

A7/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system"
+}

A7/moving_box.py

@@ -0,0 +1,144 @@
+import pygame
+from random import randint
+
+object_position = []
+object_size = ()
+object_speed = []
+size = (640, 400)
+sch_pos = size[0]/2 - size[0]/8   #Mittig - Hälfte der Schlägerbreite
+sch_speed = 0           #VArtiable zur festlegung der Position
+sch_base_speed = 7      #Verschiebungsgeschwindigkeit
+
+game_over = False       #Festlegen wenn Game Over
+
+wuerfel = randint(1, 7) # Ganze Zufallszahl aus [1, …, 7[
+
+def init():
+    global object_position
+    global object_size, object_speed
+    global object_image
+    global paddle_speed
+    object_image = pygame.image.load('ohm.png')
+
+    # Initialisierung der Bibliothek pygame
+    pygame.init()
+
+    # Vorbereiten der Oberfäche
+    pygame.display.set_mode(size)
+    pygame.display.set_caption("Pong!")
+
+    # Spieldaten initialisieren
+    object_position = [size[0]/2, size[1]/2]
+    object_speed = [randint(1,7), randint(1,7)]
+    object_size = (50, 50)
+
+def draw():
+    # Benötigte Farben als RGB-Werte
+    black = (0, 0, 0)
+    red = (255, 0, 0)
+
+    # Zeichnen des aktuellen Spielzustands
+    window = pygame.display.get_surface()
+    window.fill(black)
+    window.blit(object_image, object_position)
+    #Schläger Größe ans Fenster Anspassen
+    schläger = pygame.Rect(sch_pos,
+                           size[1]-22,
+                           size[0]/4,
+                           size[1]/25)
+    pygame.draw.rect(window, red, schläger)     # und Zeichnen, mit der position schläger
+
+    if game_over:
+        font = pygame.font.SysFont(None, 60)
+        text = font.render("GAME OVER", True, (255, 255, 255))
+        window.blit(text, (180, 150))
+
+    pygame.display.flip()
+    # "Umschalten" der aktuellen Anzeige auf die
+    # gerade gezeichnete Anzeige
+
+def update():
+    global object_position
+    global object_speed
+    global sch_pos
+    global game_over
+
+    sch_pos += sch_speed
+
+    # Abmessungen des Game-Fensters ermitteln
+    window = pygame.display.get_surface()
+    window_size = (window.get_width(),
+                   window.get_height())
+    
+    #Hier wird das erste mal die Dimensionen festgelegt, wichtig für Kollision
+    logo_rect = pygame.Rect(
+    object_position[0],
+    object_position[1],
+    object_size[0],
+    object_size[1]
+    )
+
+    #eigentlich kann ich den aus draw() übernehmen aber ich hab vergessen wie
+    schläger = pygame.Rect(
+        sch_pos,
+        size[1]-22,
+        size[0]/4,
+        size[1]/25
+    )
+    #y-Richtung umdrehen
+    if logo_rect.colliderect(schläger) and object_speed[1] > 0:
+        object_speed[1] *= -1
+
+
+    #Bouncing
+    for dim in [0, 1]:
+        
+        # Bewegung des Objekts
+        object_position[dim] += object_speed[dim]
+        # Bouncing?
+        if object_position[dim] < 0:
+            object_speed[dim] *= -1
+        end = object_position[dim] + object_size[dim]
+        if end > window_size[dim]:
+            object_speed[dim] *= -1
+
+    if object_position[1] + object_size[1] >= size[1]:      #Position = Wert von 0 bis 400 - oben links, size[o] = 40 (oderso), wenn die zusammen gleich oder größer sind als das Window in Vertikal, berührt das Logo die untere Kante
+        game_over = True
+
+        
+
+
+def user_input():
+    global sch_speed
+    global sch_base_speed
+    global game_over
+
+    # Alle Events seit dem letzten Durchlauf
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            return False
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_ESCAPE:
+                return False
+            if event.key == pygame.K_LEFT:      #Linksclick
+                sch_speed = -sch_base_speed
+            if event.key == pygame.K_RIGHT:     #Rechtsclick
+                sch_speed = sch_base_speed
+
+        if event.type == pygame.KEYUP:
+            if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:       #Key wieder hoch
+                sch_speed = 0           
+
+    return True
+
+init()
+
+running = True
+
+clock=pygame.time.Clock()
+
+while running:
+    clock.tick(60) # max 60 frames / sec
+    running = user_input()
+    update()
+    draw()

A8/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system"
+}

A8/pong-oo_aufgabe.py

@@ -0,0 +1,253 @@
+import pygame
+from random import randint
+
+OBJ_OVER = "GameOver"
+OBJ_BALL = "Ball"
+OBJ_PADDLE = "Paddle"
+OBJ_SCORE = "Score"
+
+###############################################################################
+
+class GameObject():
+    """
+    Oberklasse für alle Objekte im Spiel
+    Jedes Objekt sollte sich selbst aktualisieren und darstellen können
+    """
+    def update(self, game_objects):
+        pass
+
+    def draw(self, window):
+        pass
+
+###############################################################################
+
+class Window(GameObject):
+    """
+    Das eigentliche Fenster für das Spiel
+    Stellt den schwarzen Hintergrund dar und wird daher als erstes gezeichnet
+    Steuert auch die Spielgeschwindigkeit
+    """
+    def __init__(self):
+        self.width = 640
+        self.height = 480
+        self.title = "Pong"
+
+        pygame.init()
+        pygame.display.set_caption(self.title)
+        self.size = (self.width, self.height)
+        self.screen = pygame.display.set_mode(self.size)
+        self.clock = pygame.time.Clock()
+
+    def update(self, game_objects):
+        self.clock.tick(50)
+
+    def draw(self, window=None):
+        black = (0, 0, 0)
+        self.screen.fill(black)
+
+###############################################################################
+
+class GameOverLabel(GameObject):
+    """
+    Boolsches "Objekt", das festhält, ob das Spiel verloren wurde
+    Stellt in diesem Fall die Game Over Schrift bereit
+    """
+    def __init__(self, window):
+        font = pygame.font.Font(None, 36)
+        self.image = font.render('Game Over', 1, (255, 255, 255))
+        self.rect = self.image.get_rect(centerx=window.width // 2,
+                                        centery=window.height // 2)
+        self.is_over = False
+
+    def draw(self, window):
+        if self.is_over:
+            window.screen.blit(self.image, self.rect)
+
+###############################################################################
+
+class BouncingBall(GameObject):
+    """
+    Das wandernde Ohm-Zeichen
+    Abprallen wird im Rahmen der Aktualisierung berechnet
+    Darstellung nur, wenn nicht gerade "Game Over angezeigt wird"
+    """
+
+    def __init__(self, window):
+
+        self.size = [window.width, window.height]
+
+        self.object_image = pygame.image.load('ohm.png')
+        self.object_size = (50, 50)
+        self.object_position = [window.width / 2 - self.object_size[0] / 2, window.height /2 - self.object_size[1]]
+#        self.object_speed = [randint(1,7), randint(1,7)]
+        self.object_speed = [5,5]
+
+        self.rect = pygame.Rect(self.object_position[0],
+                                self.object_position[1],
+                                self.object_size[0],
+                                self.object_size[1])
+
+    def update(self, game_objects):
+
+        if game_objects[OBJ_OVER].is_over:
+            return
+
+        for dim in [0, 1]:
+            # Bewegung des Objekts
+            self.object_position[dim] += self.object_speed[dim]
+            # Bouncing?
+            if self.object_position[dim] < 0:
+                self.object_speed[dim] *= -1
+            end = self.object_position[dim] + self.object_size[dim]
+            if end > self.size[dim]:
+                self.object_speed[dim] *= -1
+
+        if self.object_position[1] + self.object_size[1] > self.size[1]:
+            game_objects[OBJ_OVER].is_over = True
+            
+        ## rect aktualisieren, damit die Kollision stimmt ##
+
+        self.rect.x = self.object_position[0]
+        self.rect.y = self.object_position[1]
+
+        ## Bouncing bei Schlägertreff ##
+
+        paddle = game_objects[OBJ_PADDLE]
+
+        if self.rect.colliderect(paddle.rect):
+            self.object_speed[1] *= -1
+            
+        
+    def draw(self, window):
+        
+        window.screen.blit(self.object_image, self.object_position)
+        
+
+###############################################################################
+
+class Paddle(GameObject):
+    """
+    Der Schläger
+    Darstellung nur, wenn nicht gerade "Game Over angezeigt wird"
+    """
+    def __init__(self, window):
+        self.width = 100
+        self.height = 10
+        x = window.width // 2 - self.width // 2
+        y = window.height - 2 * self.height
+        self.rect = pygame.Rect(x, y, self.width, self.height)
+        self.color =  (255, 0, 0)  # rot
+        self.speed = 10
+        self.dx = 0
+        self.dy = 0
+
+    def update(self, game_objects):
+        
+        self.rect.x += self.dx
+        self.rect.y += self.dy
+        
+
+    def draw(self, window):
+        pygame.draw.rect(window.screen, self.color, self.rect)
+        
+
+###############################################################################
+
+class Score(GameObject):
+    
+    def __init__(self, window):
+        self.window = window
+        self.score = 0
+
+    def increment(self, game_objects):
+        
+        self.score += 100
+
+    def draw(self, window):
+        pass
+
+
+
+def main():
+    """
+    Main-Funktion mit Game-Loop
+    Hostet die beiden zentralen Variablen "window" und "game_objects"
+    """
+    window = Window()
+    
+    game_objects = dict()
+    init(window, game_objects)
+
+    running = True
+
+        
+
+    while running:
+        running = user_input(window, game_objects)
+        update(window, game_objects)
+        draw(window, game_objects)
+
+def init(window : Window, game_objects):
+    """
+    Anlegen aller Objekte des Spiels
+    """
+    game_objects[OBJ_OVER] = GameOverLabel(window)
+    game_objects[OBJ_BALL] = BouncingBall(window)
+    game_objects[OBJ_PADDLE] = Paddle(window)
+
+
+def user_input(window, game_objects):
+    """
+    Abarbeiten aller Events
+    :return: False, falls das Spiel beendet wird, sonst True
+    """
+
+    def process_event():
+        """
+        Verarbeitung eines Events
+        """
+        if event.type == pygame.QUIT:
+            return False
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_ESCAPE:
+                return False
+            if event.key == pygame.K_SPACE and game_objects[OBJ_OVER].is_over:
+                init(window, game_objects)
+            if event.key == pygame.K_LEFT:
+                game_objects[OBJ_PADDLE].dx -= game_objects[OBJ_PADDLE].speed
+            if event.key == pygame.K_RIGHT:
+                game_objects[OBJ_PADDLE].dx += game_objects[OBJ_PADDLE].speed
+        if event.type == pygame.KEYUP:
+            if event.key == pygame.K_LEFT:
+                game_objects[OBJ_PADDLE].dx += game_objects[OBJ_PADDLE].speed
+            if event.key == pygame.K_RIGHT:
+                game_objects[OBJ_PADDLE].dx -= game_objects[OBJ_PADDLE].speed
+        return True
+
+    result = True
+    for event in pygame.event.get():
+        result = result and process_event()
+    return result
+
+
+def update(window, game_objects):
+    """
+    Aktualisierung aller Objekt
+    """
+    window.update(game_objects)
+    for o in game_objects.values():
+        o.update(game_objects)
+
+
+def draw(window, game_objects):
+    """
+    Zeichnen aller Objekte
+    """
+    window.draw()
+    for o in game_objects.values():
+        o.draw(window)
+    pygame.display.flip()
+
+
+if __name__ == "__main__":
+    main()