¡Feliz Navidad!

pip install pygame and enjoy little elf!!

import pygame
import sys
import random

class Snowflake:
    def __init__(self):
        self.x = random.randint(0, width)
        self.y = random.randint(0, height)
        self.size = random.randint(1, 3)
        self.speed = random.randint(1, 3)

    def update(self):
        self.y += self.speed
        if self.y > height:
            self.y = 0
            self.x = random.randint(0, width)

# Clase para representar el láser
class Laser:
    def __init__(self, x, y):
        self.rect = pygame.Rect(x, y, 4, 10)
        self.speed = 10

# Inicializar Pygame
pygame.init()

# Configuraciones generales
width, height = 800, 600
paddle_width, paddle_height = 100, 10
snowball_radius = 12
brick_width, brick_height = 40, 30
brick_padding = 5

# Configuraciones para el ladrillo de diamante y láser
diamond_brick_width, diamond_brick_height = 40, 30
diamond_brick_color = (128, 128, 128)  # Gris para el ladrillo de diamante
max_lasers = 0  # Número máximo de láseres disponibles al inicio

# Colores
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
yellow = (255, 255, 0)

# Inicializar la pantalla
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Christmas Arkanoid")

# Inicializar la paleta y la bola de nieve
paddle = pygame.Rect((width - paddle_width) // 2, height - paddle_height - 10, paddle_width, paddle_height)
snowball = pygame.Rect(width // 2, height // 2, snowball_radius * 2, snowball_radius * 2)
snowball_speed = [4, 4]  # Velocidad inicial de la bola

# Inicializar los ladrillos de colores en forma de árbol y el ladrillo de diamante
bricks = []
tree_height = 5
diamond_brick_created = False  # Bandera para asegurarse de que solo hay un ladrillo de diamante

for i in range(tree_height):
    for j in range(i + 1):
        brick_x = (j - i // 2) * (brick_width + brick_padding) + width // 2
        brick_y = i * (brick_height + brick_padding)
        bricks.append({"rect": pygame.Rect(brick_x, brick_y, brick_width, brick_height),
                       "color": random.choice([red, green, blue, yellow]),
                       "flashing": False, "falling": False})

        # Agregar un ladrillo de diamante en el centro de la pantalla
        if not diamond_brick_created and i == tree_height // 2 and j == tree_height // 2:
            bricks[-1]["rect"] = pygame.Rect(brick_x, brick_y, diamond_brick_width, diamond_brick_height)
            bricks[-1]["color"] = diamond_brick_color
            diamond_brick_created = True

# Velocidades de movimiento
paddle_speed = 7  # Ajustar la velocidad de la paleta
base_snowball_speed = [3, 3]  # Ajustar la velocidad base de la bola
snowball_speed_increment = 0.4  # Incremento de velocidad por cada ladrillo roto

# Fuente y texto
font = pygame.font.Font(None, 36)
score_font = pygame.font.Font(None, 24)
message_font = pygame.font.Font(None, 48)

# Puntuación
score = 0

# Lista de regalos
gifts = []

# Regalo
gift_width, gift_height = 15, 15
gift_speed = 7
gift = None

# Velocidad de caída del ladrillo
brick_fall_speed = 2

# Mensaje de juego terminado
game_over_message = None

# Efecto de nieve
snowflakes = [Snowflake() for _ in range(100)]

# Lista de láseres
lasers = []

# Número de láseres disponibles
lasers_available = max_lasers

# Bucle principal del juego
waiting_for_space = True
game_running = True

while game_running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE and waiting_for_space:
                waiting_for_space = False
                snowball_speed = [4, 4]  # Ajustar la velocidad de la bola al juego
            elif event.key == pygame.K_SPACE and lasers_available > 0:
                lasers.append(Laser(paddle.centerx - 2, paddle.top))
                lasers_available -= 1

    if waiting_for_space:
        screen.fill(black)
        screen.blit(font.render("Ho ho ho! Pulsa tecla espacio para comenzar", True, white), (150, height // 2 - 20))
        pygame.display.flip()
        continue

    # Mover la paleta con las teclas de flecha
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and paddle.left > 0:
        paddle.x -= paddle_speed
    if keys[pygame.K_RIGHT] and paddle.right < width:
        paddle.x += paddle_speed

    # Mover la bola de nieve
    snowball.x += snowball_speed[0]
    snowball.y += snowball_speed[1]

    # Rebote en los bordes
    if snowball.left <= 0 or snowball.right >= width:
        snowball_speed[0] = -snowball_speed[0]
    if snowball.top <= 0:
        snowball_speed[1] = -snowball_speed[1]

    # Rebote en la paleta
    if snowball.colliderect(paddle):
        snowball_speed[1] = -snowball_speed[1]

    # Colisión con los ladrillos
    for brick_info in bricks:
        brick = brick_info["rect"]
        if snowball.colliderect(brick):
            brick_info["flashing"] = True
            if brick_info["color"] == yellow:
                # Dibujar un regalo con un lazo rojo
                pygame.draw.rect(screen, red, brick_info["rect"])
                pygame.draw.line(screen, red, brick_info["rect"].topleft, brick_info["rect"].bottomright, 2)
                pygame.draw.line(screen, red, brick_info["rect"].topright, brick_info["rect"].bottomleft, 2)

                gifts.append({"rect": brick, "speed": gift_speed})  # Añadir un regalo por cada ladrillo amarillo
                brick_info["falling"] = True  # Marcar el ladrillo como que está cayendo
            elif brick_info["color"] == diamond_brick_color:  # Ladrillo de diamante (gris)
                # Incrementar el número de láseres disponibles al golpear el ladrillo gris (diamante)
                lasers_available += 2
            else:
                snowball_speed[1] += snowball_speed_increment
                score += 5
                snowball_speed[0] = -snowball_speed[0]

    # Eliminar los ladrillos que están marcados como "flashing"
    bricks = [brick for brick in bricks if not brick["flashing"]]

    # Mover los ladrillos que están cayendo
    for brick_info in bricks:
        if brick_info["falling"]:
            brick_info["rect"].y += brick_fall_speed

    # Mover los regalos que están cayendo
    for gift_info in gifts:
        gift_info["rect"].y += gift_info["speed"]

        # Verificar si el regalo colisiona con la paleta
        if gift_info["rect"].colliderect(paddle):
            score += 10
            gifts.remove(gift_info)  # Eliminar el regalo después de sumar puntos

        # Verificar si el regalo ha llegado al fondo de la pantalla
        if gift_info["rect"].bottom > height:
            gifts.remove(gift_info)  # Eliminar el regalo si llega al fondo sin ser recogido

    # Mover los láseres y verificar colisiones con ladrillos
    for laser in lasers:
        laser.rect.y -= laser.speed

        # Verificar colisión con ladrillos
        for brick_info in bricks:
            if laser.rect.colliderect(brick_info["rect"]):
                bricks.remove(brick_info)
                lasers.remove(laser)
                score += 10

        # Verificar colisión con el ladrillo de diamante
        if brick_info["color"] == diamond_brick_color and laser.rect.colliderect(brick_info["rect"]):
            lasers.remove(laser)
            score += 20

        # Verificar si el láser ha llegado al borde superior
        if laser.rect.bottom < 0:
            lasers.remove(laser)

    # Limpiar la pantalla
    screen.fill(black)

    # Dibujar los copos de nieve
    for snowflake in snowflakes:
        snowflake.update()
        pygame.draw.circle(screen, white, (snowflake.x, snowflake.y), snowflake.size)

    # Dibujar la paleta y la bola de nieve
    pygame.draw.rect(screen, white, paddle)
    pygame.draw.circle(screen, white, snowball.center, snowball_radius)

    # Dibujar los regalos si existen
    for gift_info in gifts:
        pygame.draw.rect(screen, red, gift_info["rect"])
        pygame.draw.line(screen, red, gift_info["rect"].topleft, gift_info["rect"].bottomright, 2)
        pygame.draw.line(screen, red, gift_info["rect"].topright, gift_info["rect"].bottomleft, 2)

    # Dibujar los láseres
    for laser in lasers:
        pygame.draw.rect(screen, green, laser.rect)

    # Dibujar los ladrillos de colores restantes y manejar el parpadeo
    for brick_info in bricks:
        brick = brick_info["rect"]
        color = brick_info["color"]

        if brick_info["flashing"]:
            pygame.draw.rect(screen, black, brick)
            brick_info["flashing"] = False
        else:
            pygame.draw.rect(screen, color, brick)

    # Dibujar el contador de láseres disponibles
    laser_text = score_font.render(f"Láseres: {lasers_available}", True, white)
    laser_rect = laser_text.get_rect(topleft=(10, 10))
    screen.blit(laser_text, laser_rect)

    # Dibujar la puntuación en la parte superior derecha
    score_text = score_font.render(f"Puntuación: {score}", True, white)
    score_rect = score_text.get_rect(topleft=(width - 150, 10))
    screen.blit(score_text, score_rect)

    # Verificar si la bola ha pasado la paleta
    if snowball.top > height:
        game_over_message = "Game over naughty child!"

    # Verificar si todos los ladrillos han sido eliminados
    if not bricks:
        game_over_message = "Congratz & Merry X-Mas from Hackplayers"

    # Mostrar el mensaje de juego terminado si es necesario
    if game_over_message:
        message_surface = message_font.render(game_over_message, True, white)
        message_rect = message_surface.get_rect(center=(width // 2, height // 2))
        screen.blit(message_surface, message_rect)
        pygame.display.flip()
        pygame.time.delay(3000)  # Mostrar el mensaje durante 3 segundos antes de salir
        game_running = False

    # Actualizar la pantalla
    pygame.display.flip()

    # Controlar la velocidad del bucle
    pygame.time.Clock().tick(60)

# Finalizar Pygame
pygame.quit()
sys.exit()

Ho ho ho!
2013
2014
2015
2016
2017
2018
2019
2020
2021 2022…