import pygame
import sys

# Pygame initialisieren
pygame.init()

# **Fullscreen-Modus aktivieren**
W, H = pygame.display.Info().current_w, pygame.display.Info().current_h
fenster = pygame.display.set_mode((W, H), pygame.FULLSCREEN)
pygame.display.set_caption("Jump and Run")

# **Hintergrund laden**
hintergrund = pygame.image.load("C:/PythonProgramme/Bilder/hintergrund.png").convert()
hintergrund = pygame.transform.scale(hintergrund, (W, H))

# Konstanten für die Spielwelt
BODEN_OFFSET = 180  # Passe diesen Wert an, bis der Charakter auf dem gezeichneten Boden steht
BODEN_Y = H - BODEN_OFFSET  # Der neue Boden ist nun höher als der Bildschirmrand

# **Plattformen definieren** - Positionen relativ zum neuen Boden
plattformen = [
    pygame.Rect(W // 4, BODEN_Y - 200, 200, 20),      # Erste Plattform
    pygame.Rect(W // 2, BODEN_Y - 350, 200, 20),      # Zweite Plattform
    pygame.Rect(3 * W // 4, BODEN_Y - 500, 200, 20),  # Dritte Plattform
]

# **Animationen laden**
charakter_animationen = {
    "idle": [pygame.image.load("C:/PythonProgramme/Bilder/idle.png").convert_alpha()],
    "laufen": [
        pygame.image.load("C:/PythonProgramme/Bilder/laufen_1.png").convert_alpha(),
        pygame.image.load("C:/PythonProgramme/Bilder/laufen_2.png").convert_alpha(),
    ],
    "rennen": [
        pygame.image.load("C:/PythonProgramme/Bilder/rennen_1.png").convert_alpha(),
        pygame.image.load("C:/PythonProgramme/Bilder/rennen_2.png").convert_alpha(),
    ],
    "schleichen": [
        pygame.image.load("C:/PythonProgramme/Bilder/schleichen_1.png").convert_alpha(),
        pygame.image.load("C:/PythonProgramme/Bilder/schleichen_2.png").convert_alpha(),
    ],
    "springen": [pygame.image.load("C:/PythonProgramme/Bilder/springen.png").convert_alpha()],
}

# **Charaktergröße beibehalten (700x550)**
CHARAKTER_BREITE = 700
CHARAKTER_HOEHE = 550
for key in charakter_animationen:
    charakter_animationen[key] = [
        pygame.transform.smoothscale(img, (CHARAKTER_BREITE, CHARAKTER_HOEHE)) for img in charakter_animationen[key]
    ]

# **Startposition des Charakters**
start_x = W // 4
spieler_rect = pygame.Rect(0, 0, CHARAKTER_BREITE, CHARAKTER_HOEHE)  # Größe beibehalten
spieler_rect.bottom = BODEN_Y
spieler_rect.x = start_x

# Kollisionsbox-Offset (anpassen nach Bedarf)
KOLLISION_OFFSET_X = 250  # Offset von links
KOLLISION_BREITE = 70    # Breite der Kollisionsbox
KOLLISION_HOEHE = 100     # Höhe der Kollisionsbox

# **Geschwindigkeiten**
geschwindigkeit = 5
laufgeschwindigkeit = 10
schleichgeschwindigkeit = 3
luftgeschwindigkeit = 4

# **Animation & Bewegung**
aktueller_status = "idle"
aktuelles_bild_index = 0
letztes_update = pygame.time.get_ticks()
animations_speed = 200
richtung_links = False

# **Sprungvariablen**
springt = False
sprunghöhe = 18
schwerkraft = 0.8
y_geschwindigkeit = 0

# **Kollisionsbox des Spielers**
def get_kollisionsbox():
    if richtung_links:
        # Wenn der Charakter nach links schaut, Offset von rechts berechnen
        return pygame.Rect(
            spieler_rect.right - (KOLLISION_OFFSET_X + KOLLISION_BREITE),
            spieler_rect.bottom - KOLLISION_HOEHE,
            KOLLISION_BREITE,
            KOLLISION_HOEHE
        )
    else:
        # Wenn der Charakter nach rechts schaut
        return pygame.Rect(
            spieler_rect.x + KOLLISION_OFFSET_X,
            spieler_rect.bottom - KOLLISION_HOEHE,
            KOLLISION_BREITE,
            KOLLISION_HOEHE
        )

# **Kollisionserkennung für Plattformen**
def auf_plattform():
    kollisionsbox = get_kollisionsbox()
    fußbox = pygame.Rect(
        kollisionsbox.x,
        kollisionsbox.bottom - 10,
        kollisionsbox.width,
        20
    )

    for plattform in plattformen:
        if fußbox.colliderect(plattform):
            return plattform
    if kollisionsbox.bottom >= BODEN_Y:
        return "boden"
    return None

# DEBUG: Hilfsfunktion zum Zeichnen der Kollisionsbox
def zeichne_kollisionsbox():
    kollisionsbox = get_kollisionsbox()
    pygame.draw.rect(fenster, (255, 0, 0), kollisionsbox, 2)  # Rote Box
    fußbox = pygame.Rect(
        kollisionsbox.x,
        kollisionsbox.bottom - 10,
        kollisionsbox.width,
        20
    )
    pygame.draw.rect(fenster, (0, 255, 0), fußbox, 2)  # Grüne Box für Füße

# **Spiel-Loop**
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN and event.key == pygame.K_F11:
            pygame.display.toggle_fullscreen()

    tasten = pygame.key.get_pressed()
    neues_status = "idle"

    # **Springen**
    plattform_kollision = auf_plattform()
    if tasten[pygame.K_UP] and plattform_kollision:
        springt = True
        y_geschwindigkeit = -sprunghöhe

    # **Bewegung während Sprung und Fallen**
    spieler_rect.y += y_geschwindigkeit
    y_geschwindigkeit += schwerkraft

    # **Bewegung und Status-Updates**
    if not springt:
        if tasten[pygame.K_LEFT] and tasten[pygame.K_LSHIFT]:
            spieler_rect.x -= laufgeschwindigkeit
            neues_status = "rennen"
            richtung_links = True
        elif tasten[pygame.K_RIGHT] and tasten[pygame.K_LSHIFT]:
            spieler_rect.x += laufgeschwindigkeit
            neues_status = "rennen"
            richtung_links = False
        elif tasten[pygame.K_LEFT]:
            spieler_rect.x -= schleichgeschwindigkeit if tasten[pygame.K_DOWN] else geschwindigkeit
            neues_status = "schleichen" if tasten[pygame.K_DOWN] else "laufen"
            richtung_links = True
        elif tasten[pygame.K_RIGHT]:
            spieler_rect.x += schleichgeschwindigkeit if tasten[pygame.K_DOWN] else geschwindigkeit
            neues_status = "schleichen" if tasten[pygame.K_DOWN] else "laufen"
            richtung_links = False
    else:
        if tasten[pygame.K_LEFT]:
            spieler_rect.x -= luftgeschwindigkeit
            richtung_links = True
        if tasten[pygame.K_RIGHT]:
            spieler_rect.x += luftgeschwindigkeit
            richtung_links = False
        neues_status = "springen"

    # **Plattform-Kollision überprüfen**
    plattform_kollision = auf_plattform()
    if plattform_kollision:
        if plattform_kollision == "boden":
            spieler_rect.bottom = BODEN_Y
            y_geschwindigkeit = 0
            springt = False
        else:
            spieler_rect.bottom = plattform_kollision.top
            y_geschwindigkeit = 0
            springt = False
    elif spieler_rect.bottom >= BODEN_Y:  # Überprüfen, ob der Boden erreicht wurde
        springt = False
        y_geschwindigkeit = 0

    # **Animation aktualisieren**
    if neues_status != aktueller_status:
        aktueller_status = neues_status
        aktuelles_bild_index = 0
        letztes_update = pygame.time.get_ticks()

    # **Frame-Wechsel für Animation**
    jetzt = pygame.time.get_ticks()
    if jetzt - letztes_update > animations_speed:
        aktuelles_bild_index += 1
        if aktuelles_bild_index >= len(charakter_animationen[aktueller_status]):
            aktuelles_bild_index = 0
        letztes_update = jetzt

    # **Figur im Fenster halten**
    if spieler_rect.left < 0:
        spieler_rect.left = 0
    if spieler_rect.right > W:
        spieler_rect.right = W

    # **Zeichnen**
    fenster.blit(hintergrund, (0, 0))

    # Plattformen zeichnen
    for plattform in plattformen:
        pygame.draw.rect(fenster, (100, 100, 100), plattform)

    # **Charakter zeichnen**
    aktuelles_bild = charakter_animationen[aktueller_status][aktuelles_bild_index]
    if richtung_links:
        aktuelles_bild = pygame.transform.flip(aktuelles_bild, True, False)

    # Berechne die Position des Charakterbildes relativ zur Kollisionsbox
    kollisionsbox = get_kollisionsbox()
    charakter_y = kollisionsbox.bottom - aktuelles_bild.get_height() + 180 # Charakter sitzt auf der Kollisionsbox
    charakter_x = kollisionsbox.centerx - (aktuelles_bild.get_width() // 2)  # Charakter ist zentriert über der Kollisionsbox

    # Zeichne den Charakter an der berechneten Position
    fenster.blit(aktuelles_bild, (charakter_x, charakter_y))

    # Debug: Kollisionsbox zeichnen (zum Testen)
    zeichne_kollisionsbox()

    pygame.display.flip()
    pygame.time.Clock().tick(60)

pygame.quit()
sys.exit()