import pygame
import sys
import random
from pygame.locals import *

Negro = (0, 0, 0)
class Jugador(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.quieto = pygame.image.load("Imagenes/Idle.jpg")
        self.Caminaderecha = [pygame.image.load("Imagenes/Run.png"),
                              pygame.image.load("Imagenes/Run (1).png"),
                              pygame.image.load("Imagenes/Run (2).png"),
                              pygame.image.load("Imagenes/Run (3).png"),
                              pygame.image.load("Imagenes/Run (4).png"),
                              pygame.image.load("Imagenes/Run (5).png"),
                              pygame.image.load("Imagenes/Run (6).png"),
                              pygame.image.load("Imagenes/Run (7).png")]
        self.Caminarizquierda = [pygame.image.load("Imagenes/image.png"),
                                 pygame.image.load("Imagenes/image (1).png"),
                                 pygame.image.load("Imagenes/image (2).png"),
                                 pygame.image.load("Imagenes/image (3).png"),
                                 pygame.image.load("Imagenes/image (4).png"),
                                 pygame.image.load("Imagenes/image (5).png"),
                                 pygame.image.load("Imagenes/image (6).png"),
                                 pygame.image.load("Imagenes/image (7).png")]
        self.Saltar = [pygame.image.load("Imagenes/Jump.png"),
                       pygame.image.load("Imagenes/Jump (1).png")]
        self.image = self.quieto
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.velocidad = 4
        self.gravedad = 0.5
        self.velocidad_y = 0
        self.en_el_suelo = False
        self.cuentapasos = 0
        self.direccion = 1
        self.vidas = 3  # Vidas del jugador
        self.vida_maxima = 100
        self.vida_actual = self.vida_maxima  # Barra de vida del jugador
        self.cooldown_ataque = 0  # Tiempo de espera entre ataques
        self.cooldown_ataque_max = 30  # Máximo tiempo de espera entre ataques
        self.danio = 10  # Daño que hace el jugador al enemigo

        # Cargar el sonido del ataque
        self.sonido_ataque = pygame.mixer.Sound("Sonidos/slash-21834.mp3")

    def update(self, keys, plataformas):
        if keys[K_LEFT] and self.rect.x > 0:
            self.rect.x -= self.velocidad
            self.direccion = -1
        elif keys[K_RIGHT] and self.rect.x < W - self.rect.width:
            self.rect.x += self.velocidad
            self.direccion = 1

        # Aplicar gravedad
        if not self.en_el_suelo:
            self.velocidad_y += self.gravedad
            self.rect.y += self.velocidad_y

        # Verificar colisión con las plataformas
        for plataforma in plataformas:
            if self.rect.colliderect(plataforma.rect):
                if self.velocidad_y > 0:
                    self.rect.bottom = plataforma.rect.top
                    self.en_el_suelo = True
                    self.velocidad_y = 0
                    break

        if self.rect.y >= H - self.rect.height:
            self.rect.y = H - self.rect.height
            self.en_el_suelo = True
            self.velocidad_y = 0

        # Actualizar la animación
        if self.en_el_suelo:
            if keys[K_LEFT] or keys[K_RIGHT]:
                if self.direccion == 1:
                    self.image = self.Caminaderecha[self.cuentapasos // 10 % len(self.Caminaderecha)]
                else:
                    self.image = self.Caminarizquierda[self.cuentapasos // 10 % len(self.Caminarizquierda)]
                self.cuentapasos += 1
            else:
                self.image = self.quieto
                self.cuentapasos = 0
        else:
            self.image = self.Saltar[self.direccion > 0]

        # Actualizar el tiempo de espera entre ataques
        if self.cooldown_ataque > 0:
            self.cooldown_ataque -= 1

    def saltar(self):
        if self.en_el_suelo:
            self.velocidad_y = -12  # Ajusta la velocidad de salto según sea necesario
            self.en_el_suelo = False

    def atacar(self):
        if self.cooldown_ataque == 0:
            nuevo_ataque = Ataque(self.rect.x + (self.rect.width if self.direccion == 1 else -20), self.rect.centery,
                                  self.direccion)
            ataques.add(nuevo_ataque)
            self.cooldown_ataque = self.cooldown_ataque_max

            # Reproducir el sonido del ataque
            self.sonido_ataque.play()

    def recibir_danio(self, cantidad):
        self.vida_actual -= cantidad
        if self.vida_actual <= 0:
            self.vidas -= 1
            self.vida_actual = self.vida_maxima

    def atacar_izquierda(self):
        if self.cooldown_ataque == 0:
            nuevo_ataque = Ataque(self.rect.x + (self.rect.width if self.direccion == 1 else -20), self.rect.centery,
                                  -1)
            ataques.add(nuevo_ataque)
            self.cooldown_ataque = self.cooldown_ataque_max


class Plataforma(pygame.sprite.Sprite):
    def __init__(self, x, y, width, height, image_path):
        super().__init__()
        self.image = pygame.image.load("Imagenes/tileset (1).png").convert()
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y

class Menu:
    def __init__(self, screen):
        self.screen = screen
        self.font = pygame.font.SysFont(None, 30)
        self.text = self.font.render("Presiona ENTER para empezar", True, (255, 255, 255))
        self.text_rect = self.text.get_rect(center=self.screen.get_rect().center)

        def mostrar(self):
            self.screen.fill((0, 0, 0))
            self.screen.blit(self.text, self.text_rect)
            pygame.display.flip()
class Enemigo(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.enemigo_images = [pygame.image.load("Enemigos/burning-ghoul-1.png"),
                               pygame.image.load("Enemigos/burning-ghoul-2.png"),
                               pygame.image.load("Enemigos/burning-ghoul-3.png"),
                               pygame.image.load("Enemigos/burning-ghoul-4.png"),
                               pygame.image.load("Enemigos/burning-ghoul-5.png"),
                               pygame.image.load("Enemigos/burning-ghoul-6.png"),
                               pygame.image.load("Enemigos/burning-ghoul-7.png"),
                               pygame.image.load("Enemigos/burning-ghoul-8.png")]
        self.image_index = 0
        self.image = self.enemigo_images[self.image_index]
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = 350
        self.velocidad_x = random.choice([-1, 1]) * random.uniform(1, 3)  # Velocidad horizontal aleatoria del enemigo
        self.danio = 1.6  # Daño que hace el enemigo al colisionar
        self.vida_maxima = 100
        self.vida_actual = self.vida_maxima
        self.muerto = False
        self.tiempo_muerte = 0

    def update(self):
        if self.muerto:
            tiempo_actual = pygame.time.get_ticks()
            if tiempo_actual - self.tiempo_muerte > 3000:  # Tiempo en milisegundos antes de reaparecer (3 segundos)
                self.muerto = False
                self.vida_actual = self.vida_maxima
                self.rect.x = random.randint(0, W - self.rect.width)
                self.rect.y = 350
        else:
            # Mover al enemigo horizontalmente
            self.rect.x += self.velocidad_x

            # Verificar colisión con los bordes de la pantalla
            if self.rect.right >= W:
                self.rect.right = W
                self.velocidad_x *= -1  # Cambiar dirección cuando choca con el borde derecho
            elif self.rect.left <= 0:
                self.rect.left = 0
                self.velocidad_x *= -1  # Cambiar dirección cuando choca con el borde izquierdo

            # Actualizar la imagen del enemigo
            self.image_index = (self.image_index + 1) % len(self.enemigo_images)
            self.image = self.enemigo_images[self.image_index]

    def recibir_danio(self, cantidad):
        self.vida_actual -= cantidad
        if self.vida_actual <= 0:
            self.muerto = True
            self.tiempo_muerte = pygame.time.get_ticks()


class Ataque(pygame.sprite.Sprite):
    def __init__(self, x, y, direccion):
        super().__init__()
        self.image = pygame.image.load("Imagenes/Espada1.png")  # Imagen del ataque
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.centery = y
        self.direccion = direccion
        self.velocidad = 8 * direccion

    def update(self):
        self.rect.x += self.velocidad


# Función para dibujar la barra de vida
def dibujar_barra_vida(surface, x, y, width, height, vida_actual, vida_maxima):
    borde_rect = pygame.Rect(x, y, width, height)
    pygame.draw.rect(surface, (255, 0, 0), borde_rect, 2)  # Borde de la barra de vida
    vida_rect = pygame.Rect(x + 1, y + 1, max(0, (vida_actual / vida_maxima) * (width - 2)), height - 2)
    pygame.draw.rect(surface, (0, 255, 0), vida_rect)  # Barra de vida


# Inicialización de pygame
pygame.init()
pygame.mixer.init()
pygame.mixer.music.load("Sonidos/Slipknot - Eyeless 8-Bit.mp3")  # Ruta de tu archivo de música
pygame.mixer.music.play(-1)  # -1 indica que la música se reproduce en bucle

W, H = 727, 500
PANTALLA = pygame.display.set_mode((W, H))
FPS = 60
RELOJ = pygame.time.Clock()
pygame.display.set_caption('Pygame')
Fondo = pygame.image.load("Imagenes/MOVIMIENTO.jpg").convert()

# Inicializar Fondo_x
Fondo_x = 0

jugador = Jugador(W // 2, 0)
plataformas = pygame.sprite.Group()
plataformas.add(Plataforma(300, 420, 200, 100, "Imagenes/platform.png"))
plataformas.add(Plataforma(400, 420, 200, 100, "Imagenes/platform.png"))
plataformas.add(Plataforma(100, 420, 200, 100, "Imagenes/platform.png"))
plataformas.add(Plataforma(0, 420, 200, 100, "Imagenes/platform.png"))
plataformas.add(Plataforma(550, 420, 200, 100, "Imagenes/platform.png"))
enemigos = pygame.sprite.Group()
enemigo = Enemigo(100, 200)  # Ajusta la posición del enemigo según sea necesario
enemigos.add(enemigo)

ataques = pygame.sprite.Group()
while True:
    RELOJ.tick(FPS)
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        elif event.type == KEYDOWN:
            if event.key == K_SPACE:
                jugador.saltar()
            elif event.key == K_e:
                jugador.atacar()
            elif event.key == K_q:
                jugador.atacar_izquierda()

    keys = pygame.key.get_pressed()

    jugador.update(keys, plataformas)
    for enemigo in enemigos:
        enemigo.update()  # Actualizar el enemigo

        # Colisión con el jugador
        if pygame.sprite.collide_rect(jugador, enemigo):
            jugador.recibir_danio(enemigo.danio)

    # Verificar colisión entre ataques y enemigos
    for ataque in ataques:
        for enemigo in enemigos:
            if pygame.sprite.collide_rect(ataque, enemigo):
                enemigo.recibir_danio(jugador.danio)
                ataques.remove(ataque)

    # Actualizar los ataques
    for ataque in ataques:
        ataque.update()

    # Mover el fondo
    Fondo_x -= 1  # Ajusta la velocidad de movimiento del fondo según sea necesario
    if Fondo_x <= -Fondo.get_width():
        Fondo_x = 0

    PANTALLA.blit(Fondo, (Fondo_x, 0))
    PANTALLA.blit(Fondo, (Fondo_x + Fondo.get_width(), 0))  # Dibuja el fondo una segunda vez después del primer fondo

    for plataforma in plataformas:
        PANTALLA.blit(plataforma.image, plataforma.rect)

    for enemigo in enemigos:
        PANTALLA.blit(enemigo.image, enemigo.rect)
        dibujar_barra_vida(PANTALLA, enemigo.rect.x, enemigo.rect.y - 10, enemigo.rect.width, 5, enemigo.vida_actual,
                           enemigo.vida_maxima)

    for ataque in ataques:
        PANTALLA.blit(ataque.image, ataque.rect)

    PANTALLA.blit(jugador.image, jugador.rect)

    # Dibujar la barra de vida del jugador
    dibujar_barra_vida(PANTALLA, jugador.rect.x, jugador.rect.y - 10, jugador.rect.width, 5, jugador.vida_actual,
                       jugador.vida_maxima)

    # Mostrar las vidas del jugador en la pantalla
    font = pygame.font.SysFont(None, 30)
    text = font.render("Vidas: " + str(jugador.vidas), True, (255, 255, 255))
    PANTALLA.blit(text, (10, 10))

    # Verificar si las vidas del jugador han llegado a cero
    if jugador.vidas <= 0:
        font = pygame.font.SysFont(None, 60)
        game_over_text = font.render("Juego Terminado", True, (255, 0, 0))
        PANTALLA.blit(game_over_text, (W // 2 - game_over_text.get_width() // 2, H // 2 - game_over_text.get_height() // 2))
        pygame.display.flip()
        pygame.time.delay(2000)  # Espera 2 segundos antes de cerrar el juego
        pygame.quit()
        sys.exit()

    pygame.display.flip()
