kollisiontext.py

+import pygame
+import math
+
+pygame.init()
+
+# Fenster erstellen
+width, height = 800, 600
+screen = pygame.display.set_mode((width, height))
+pygame.display.set_caption('Kollision Ball-Wand')
+
+# Farben
+WHITE = (255, 255, 255)
+RED = (255, 0, 0)
+
+# Ball Attribute
+ball_radius = 20
+ball_pos = [100, 300]
+ball_speed = [2, 2]
+
+# Wand Attribute (Beispiel: Rechteckige Wand)
+wall_width = 200
+wall_height = 20
+wall_pos = [400, 300]  # Beispielposition
+wall_rotation_angle = 45  # Beispielwinkel in Grad
+
+def rotate_point(pos, angle, pivot):
+    """Rotiert einen Punkt um einen Pivot-Punkt"""
+    x, y = pos
+    pivot_x, pivot_y = pivot
+    s = math.sin(math.radians(angle))
+    c = math.cos(math.radians(angle))
+    x -= pivot_x
+    y -= pivot_y
+    new_x = x * c - y * s
+    new_y = x * s + y * c
+    x = new_x + pivot_x
+    y = new_y + pivot_y
+    return x, y
+
+def check_collision(ball_pos, ball_radius, wall_pos, wall_width, wall_height, wall_rotation_angle):
+    """Überprüft Kollision zwischen Ball und Wand"""
+    rotated_wall_points = []
+    for i in range(4):
+        x = wall_pos[0] + wall_width * (i // 2) * ((i % 2) * 2 - 1)
+        y = wall_pos[1] + wall_height * (i % 2) * ((i // 2) * 2 - 1)
+        rotated_point = rotate_point((x, y), wall_rotation_angle, wall_pos)
+        rotated_wall_points.append(rotated_point)
+
+    for i in range(0, len(rotated_wall_points)):
+        x1, y1 = rotated_wall_points[i]
+        x2, y2 = rotated_wall_points[(i + 1) % len(rotated_wall_points)]
+        d = ((x2 - x1) * (ball_pos[1] - y1) - (y2 - y1) * (ball_pos[0] - x1)) / math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+        if abs(d) < ball_radius:
+            return True
+
+    return False
+
+running = True
+while running:
+    screen.fill(WHITE)
+
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Bewegung des Balls
+    ball_pos[0] += ball_speed[0]
+    ball_pos[1] += ball_speed[1]
+
+    # Kollisionsprüfung mit der Wand
+    if check_collision(ball_pos, ball_radius, wall_pos, wall_width, wall_height, wall_rotation_angle):
+        # Hier Berechnung des Ausfallswinkels nach Kollision
+        # Beispiel: Einfacher Winkelreflektion, um den Ball abzuprallen
+        ball_speed[0] *= -1
+        ball_speed[1] *= -1
+
+    # Zeichne die rotierte Wand
+    rotated_wall_points = [rotate_point((wall_pos[0] + wall_width / 2, wall_pos[1] - wall_height / 2), wall_rotation_angle, wall_pos),
+                           rotate_point((wall_pos[0] + wall_width / 2, wall_pos[1] + wall_height / 2), wall_rotation_angle, wall_pos),
+                           rotate_point((wall_pos[0] - wall_width / 2, wall_pos[1] + wall_height / 2), wall_rotation_angle, wall_pos),
+                           rotate_point((wall_pos[0] - wall_width / 2, wall_pos[1] - wall_height / 2), wall_rotation_angle, wall_pos)]
+    pygame.draw.polygon(screen, RED, rotated_wall_points)
+
+    # Zeichne den Ball
+    pygame.draw.circle(screen, RED, (int(ball_pos[0]), int(ball_pos[1])), ball_radius)
+
+    pygame.display.flip()
+
+pygame.quit()

pinball_game.py

+import pygame
+import sys
+import random
+import math
+
+
+pygame.init() 
+
+width = 600
+height = 1000
+screen = pygame.display.set_mode((width, height)) 
+pygame.display.set_caption("Stage 1")#create pygame surface
+
+#variables
+radius = 10
+gravity = 0.2
+
+
+#colors
+green = (0,255,0)
+
+
+
+lines = []
+
+
+#class for walls
+class Wall:
+    def __init__(self, pos1, pos2, color):
+        self.pos1 = pos1
+        self.pos2 = pos2
+        self.color = color
+
+    def draw(self, screen):
+        pygame.draw.line(screen, self.color, self.pos1, self.pos2)
+
+
+    def hitlines(self):
+        if abs(self.pos2[0] - self.pos1[0]) < 0.0174533 :
+            angle = math.pi / 2
+        else:
+            angle = math.atan(abs(self.pos2[1] - self.pos1[1]) / abs(self.pos2[0] - self.pos1[0]))
+        angle2 = (math.pi - (angle + math.pi / 2))
+        xplus = math.cos(angle2) * radius
+        yplus = math.sin(angle2) * radius
+        posplus = (xplus, yplus)
+
+        if self.pos2[1] - self.pos1[1] > 0:
+            nuppos1 = (self.pos1[0] + xplus, self.pos1[1] - yplus)
+            nuppos2 = (self.pos2[0] + xplus, self.pos2[1] - yplus)
+            ndopos1 = (self.pos1[0] - xplus, self.pos1[1] + yplus)
+            ndopos2 = (self.pos2[0] - xplus, self.pos2[1] + yplus)
+        elif self.pos2[1] - self.pos1[1] < 0:
+            nuppos1 = (self.pos1[0] + xplus, self.pos1[1] + yplus)
+            nuppos2 = (self.pos2[0] + xplus, self.pos2[1] + yplus)
+            ndopos1 = (self.pos1[0] - xplus, self.pos1[1] - yplus)
+            ndopos2 = (self.pos2[0] - xplus, self.pos2[1] - yplus)
+        else:
+            nuppos1 = (self.pos1[0] + xplus, self.pos1[1] + yplus)
+            nuppos2 = (self.pos2[0] + xplus, self.pos2[1] + yplus)
+            ndopos1 = (self.pos1[0] - xplus, self.pos1[1] - yplus)
+            ndopos2 = (self.pos2[0] - xplus, self.pos2[1] - yplus)
+
+        #print(angle, angle2, xplus, yplus, posplus, nuppos1, nuppos2, ndopos1, ndopos2)
+
+        lines.append((nuppos1, nuppos2))
+        lines.append((ndopos1, ndopos2))
+
+
+#class for balls
+class Ball:
+    def __init__(self, pos, color, velocity):
+        self.posx = pos[0]
+        self.posy = pos[1]
+        self.color = color
+        self.v = list(velocity)
+        self.prevposx = pos[0]
+        self.prevposy = pos[1]
+        
+
+
+    def draw(self):
+        pygame.draw.circle(screen, self.color, (self.posx, self.posy), radius)
+
+    def gravity(self):
+        print(self.v)
+        self.v[1] += gravity
+        print(self.v)
+        self.prevposx = self.posx
+        self.prevposy = self.posy
+        self.posx += self.v[0]
+        self.posy += self.v[1]
+        print(self.prevposx, self.prevposy)
+        print(self.posx, self.posy)
+        
+
+    # Nehmen wir an, du hast die Ball-Positionen (posx, posy) und den Bewegungsvektor (vx, vy)
+    # und die Linie definiert durch (x1, y1) und (x2, y2)
+
+    def check(self, x1, y1, x2, y2):
+
+        #Ray Casting
+        ray = (self.v[0], self.v[1])
+
+      
+        # Berechne den Vektor der Linie
+        line_vec = (x2 - x1, y2 - y1)
+        
+        # Berechne den Bewegungsvektor des Balls
+        ball_vec = (self.v[0], self.v[1])
+        
+        # Berechne den Vektor zwischen dem Startpunkt der Linie und der Ballposition
+        start_to_ball = (self.posx - x1, self.posy - y1)
+        
+        # Projiziere die Vektoren auf eine Senkrechte zur Linie (Separating Axis Theorem)
+        line_projection = line_vec[0] * start_to_ball[0] + line_vec[1] * start_to_ball[1]
+        ball_projection = ball_vec[0] * start_to_ball[0] + ball_vec[1] * start_to_ball[1]
+        
+        # Überprüfe auf Überlappung der Projektionen, um eine mögliche Kollision zu erkennen
+        if 0 <= line_projection <= (line_vec[0] * line_vec[0] + line_vec[1] * line_vec[1]) and \
+           0 <= ball_projection <= (ball_vec[0] * ball_vec[0] + ball_vec[1] * ball_vec[1]):
+            print("True")
+            collision_point = (self.posx - self.v[0], self.posy - self.v[1])
+            print(collision_point)
+            collision.append(collision_point)
+            return True
+        else:
+            return None
+        
+
+    def find_intersection_point(self, x1, y1, x2, y2, tolerance=1e-6):
+        x3, y3, x4, y4 = self.prevposx, self.prevposy, self.posx, self.posy
+
+        denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+
+        if abs(denominator) < tolerance:
+            return None  # Linien sind parallel oder identisch
+
+        intersection_x = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / denominator
+        intersection_y = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / denominator
+
+        if (min(x1, x2) - tolerance <= intersection_x <= max(x1, x2) + tolerance and
+                min(y1, y2) - tolerance <= intersection_y <= max(y1, y2) + tolerance and
+                min(x3, x4) - tolerance <= intersection_x <= max(x3, x4) + tolerance and
+                min(y3, y4) - tolerance <= intersection_y <= max(y3, y4) + tolerance):
+            collision.append((intersection_x, intersection_y))
+            print(True)
+            print(intersection_x, intersection_y)
+            return intersection_x, intersection_y
+        else:
+            return None  # Schnittpunkt liegt nicht auf beiden Linien
+        
+
+    def bounce(self):
+        colx = collision[0][0]
+        coly = collision[0][1]
+        if self.prevposx < colx:
+            self.posx = colx - 1
+        else:
+            self.posx = colx + 1
+        if self.prevposy < coly:
+            self.posx = colx + 1
+        else:
+            self.posx = colx - 1
+        collision.clear()
+        print(self.v)
+        self.v[0] = -0.9 * self.v[0]
+        self.v[1] = -0.9 * self.v[1]
+        print(self.v)
+      
+
+
+
+
+clock = pygame.time.Clock()
+
+#bälle
+ball1 = Ball((300,500), (255,0,0), (0,0))
+
+#horizontale Wände
+h = [
+    ((100,100), (500,100)),
+    ((100,900), (500,900)),
+]
+
+#vertikale Wände
+v = [
+    ((100,100), (100,900)),
+    ((500,100), (500,900))
+]
+
+walls = []
+for wall in h:
+    w = Wall(wall[0], wall[1], green)
+    walls.append(w)
+for wall in v:
+    w = Wall(wall[0], wall[1], green)
+    walls.append(w)
+
+lines = []
+
+for wall in walls:
+    wall.hitlines()
+
+print(lines[1])
+
+collision = []
+
+
+running = True
+while running:
+    screen.fill((255, 255, 255))
+
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+
+
+    for wall in walls:
+        wall.draw(screen)
+
+    for line in lines:
+        pygame.draw.line(screen, (0, 0, 255), line[0], line[1], 5)
+
+    ball1.draw()
+    ball1.gravity()
+
+    
+    for wall in lines:
+        if ball1.find_intersection_point(wall[0][0], wall[0][1], wall[1][0], wall[1][1],) != None:
+            ball1.bounce()
+   
+
+    pygame.display.flip()
+    clock.tick(60)
+
+pygame.quit()
\ No newline at end of file

pinballmenu.py

+import pygame
+import sys
+import tkinter
+import time
+from pygame.locals import *
+import pinball_game
+
+
+pygame.init()
+
+#constants
+FPS = 60
+width = 560
+height = 1000
+
+#colors
+white = (255,255,255)
+black = (0,0,0)
+gray = (200,200,200)
+blue = (0,0,255)
+
+
+#Display
+screen = pygame.display.set_mode((width, height))
+pygame.display.set_caption("Menu")
+
+#Fonts
+font_headline = pygame.font.Font(None, 36)
+font_button = pygame.font.Font (None, 24)
+
+#Create buttons
+button_width = 200
+button_height = 50
+button_padding = 20
+buttons_menu = [
+    pygame.Rect((width - button_width) // 2, 200 + i * (button_height + button_padding), button_width, button_height)
+    for i in range(4)
+]
+
+buttons_s = [
+    pygame.Rect((width - button_width) // 2, 200 + i * (button_height + button_padding), button_width, button_height)
+    for i in range(3)
+]
+
+
+#Texts for buttons
+button_menu = ["Singleplayer", "Multiplayer", "Highscore", "Quit"]
+button_s = ["Stage 1", "Stage 2", "Back"]
+
+#Main Game Loop
+clock = pygame.time.Clock()
+running = True
+current_screen ="menu"
+while running:
+    screen.fill(white)
+
+
+    if current_screen == "menu":
+        #Draw headline
+        headline_text = font_headline.render("Game Menu", True, black)
+        headline_rect = headline_text.get_rect(center = (width // 2, 50))
+        screen.blit(headline_text, headline_rect)
+
+        #Draw buttons
+        for i, button in enumerate(buttons_menu):
+            pygame.draw.rect(screen, gray, button)
+            text = font_button.render(button_menu[i], True, black)
+            text_rect = text.get_rect(center = button.center)
+            screen.blit(text, text_rect)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                if event.button == 1: # Left Mousebutton
+                    mouse_pos = pygame.mouse.get_pos() #Get mouse position
+                    for i, button in enumerate(buttons_menu):
+                        if button.collidepoint(mouse_pos):
+                            print(f"Button {button_menu[i]} clicked")
+                            if button_menu[i] == "Quit":
+                                running = False
+                            elif button_menu[i] == "Singleplayer":
+                                current_screen = "singleplayer"  # Switch to singleplayer screen
+                            elif button_menu[i] == "Multiplayer":
+                                current_screen = "multiplayer"  # Switch to multiplayer screen
+                            elif button_menu[i] == "Highscores":
+                                current_screen = "highscores"  # Switch to highscores screen
+
+
+
+    if current_screen == "singleplayer":
+        #Draw headline
+        headline_text = font_headline.render("Stages", True, black)
+        headline_rect = headline_text.get_rect(center = (width // 2, 50))
+        screen.blit(headline_text, headline_rect)
+
+        #Draw buttons
+        for i, button in enumerate(buttons_s):
+            pygame.draw.rect(screen, gray, button)
+            text = font_button.render(button_s[i], True, black)
+            text_rect = text.get_rect(center = button.center)
+            screen.blit(text, text_rect)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                if event.button == 1: # Left Mousebutton
+                    mouse_pos = pygame.mouse.get_pos() #Get mouse position
+                    for i, button in enumerate(buttons_s):
+                        if button.collidepoint(mouse_pos):
+                            print(f"Button {button_s[i]} clicked")
+                            if button_s[i] == "Back":
+                                current_screen = "menu"
+                            elif button_s[i] == "Stage 1":
+                                pinball_game.stage_1()
+                            elif button_s[i] == "Stage 2":
+                                earlier_screen = "singleplayer"
+                                current_screen = "error"
+
+                                
+                                                        
+
+
+    if current_screen =="multiplayer":
+        pass
+
+    if current_screen == "highscore":
+        pass
+
+    if current_screen == "error":
+        #Draw headline
+        headline_text = font_headline.render("Not yet available", True, black)
+        headline_rect = headline_text.get_rect(center = (width // 2, 50))
+        screen.blit(headline_text, headline_rect)
+
+        #Draw buttons
+        pygame.draw.rect(screen, gray, button)
+        text = font_button.render("Back", True, black)
+        text_rect = text.get_rect(center = button.center)
+        screen.blit(text, text_rect)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                if event.button == 1: # Left Mousebutton
+                    mouse_pos = pygame.mouse.get_pos() #Get mouse position
+                    if button.collidepoint(mouse_pos):
+                            print(f"Button back clicked")
+                            current_screen = earlier_screen
+                    
+
+
+    pygame.display.flip()
+    clock.tick(FPS)
+
+pygame.quit()
+sys.exit()
\ No newline at end of file

schnittpunkt.py

+def find_intersection_point(line1, line2, tolerance=1e-6):
+    x1, y1, x2, y2 = line1
+    x3, y3, x4, y4 = line2
+
+    denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+
+    if abs(denominator) < tolerance:
+        return None  # Linien sind parallel oder identisch
+
+    intersection_x = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / denominator
+    intersection_y = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / denominator
+
+    print(min(x1, x2),)
+    print(max(x1, x2),)  
+
+    print(min(y1, y2),)
+    print(max(y1, y2),)
+    print(min(x3, x4),)
+    print(max(x3, x4),)
+    print(min(y3, y4),)
+    print(max(y3, y4),)
+          
+    if (min(x1, x2) - tolerance <= intersection_x <= max(x1, x2) + tolerance and
+            min(y1, y2) - tolerance <= intersection_y <= max(y1, y2) + tolerance and
+            min(x3, x4) - tolerance <= intersection_x <= max(x3, x4) + tolerance and
+            min(y3, y4) - tolerance <= intersection_y <= max(y3, y4) + tolerance):
+        return intersection_x, intersection_y
+    else:
+        return None  # Schnittpunkt liegt nicht auf beiden Linien
+
+
+
+# Beispielwerte für die begrenzten Linien (x1, y1, x2, y2) und (x3, y3, x4, y4)
+line1 = (100, 900, 500, 900)
+line2 = (300, 890.6, 300, 903.3)
+
+intersection = find_intersection_point(line1, line2)
+
+if intersection:
+    print("Schnittpunkt der begrenzten Linien:", intersection)
+else:
+    print("Die begrenzten Linien schneiden sich nicht oder liegen parallel.")