import pygame
import random
import sys

# 初始化pygame
pygame.init()

# 游戏常量
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60

# 颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 100, 255)
YELLOW = (255, 255, 0)
GREEN = (0, 255, 0)

class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 40
        self.height = 40
        self.vel = 5
        self.rect = pygame.Rect(x, y, self.width, self.height)
        
    def move(self, keys):
        if keys[pygame.K_LEFT] and self.x > 0:
            self.x -= self.vel
        if keys[pygame.K_RIGHT] and self.x < SCREEN_WIDTH - self.width:
            self.x += self.vel
        if keys[pygame.K_UP] and self.y > 0:
            self.y -= self.vel
        if keys[pygame.K_DOWN] and self.y < SCREEN_HEIGHT - self.height:
            self.y += self.vel
            
        self.rect.x = self.x
        self.rect.y = self.y
    
    def draw(self, screen):
        # 绘制玩家（三角形飞行器）
        points = [
            (self.x + self.width//2, self.y),  # 顶部
            (self.x, self.y + self.height),     # 左下
            (self.x + self.width, self.y + self.height)  # 右下
        ]
        pygame.draw.polygon(screen, BLUE, points)
        # 添加火焰效果
        flame_points = [
            (self.x + self.width//2 - 5, self.y + self.height),
            (self.x + self.width//2, self.y + self.height + 10),
            (self.x + self.width//2 + 5, self.y + self.height)
        ]
        pygame.draw.polygon(screen, YELLOW, flame_points)
    
    def get_rect(self):
        return self.rect

class Obstacle:
    def __init__(self):
        self.width = random.randint(20, 50)
        self.height = random.randint(20, 50)
        self.x = SCREEN_WIDTH
        self.y = random.randint(0, SCREEN_HEIGHT - self.height)
        self.vel = random.randint(3, 8)
        self.rect = pygame.Rect(self.x, self.y, self.width, self.height)
        
    def update(self):
        self.x -= self.vel
        self.rect.x = self.x
        
    def draw(self, screen):
        pygame.draw.rect(screen, RED, self.rect)
        # 添加尖刺效果
        pygame.draw.polygon(screen, RED, [
            (self.x + self.width//2, self.y - 5),
            (self.x + self.width//2 - 5, self.y),
            (self.x + self.width//2 + 5, self.y)
        ])
    
    def off_screen(self):
        return self.x + self.width < 0
    
    def get_rect(self):
        return self.rect

class PowerUp:
    def __init__(self):
        self.width = 20
        self.height = 20
        self.x = SCREEN_WIDTH
        self.y = random.randint(0, SCREEN_HEIGHT - self.height)
        self.vel = 4
        self.rect = pygame.Rect(self.x, self.y, self.width, self.height)
        self.type = random.choice(['shield', 'slow', 'score'])
        
    def update(self):
        self.x -= self.vel
        self.rect.x = self.x
        
    def draw(self, screen):
        color = GREEN if self.type == 'score' else YELLOW
        pygame.draw.circle(screen, color, (self.x + self.width//2, self.y + self.height//2), self.width//2)
        # 显示道具类型
        font = pygame.font.Font(None, 20)
        text = font.render(self.type[0].upper(), True, BLACK)
        screen.blit(text, (self.x + 5, self.y + 5))
    
    def off_screen(self):
        return self.x + self.width < 0
    
    def get_rect(self):
        return self.rect

class Particle:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.vx = random.uniform(-5, 5)
        self.vy = random.uniform(-5, 5)
        self.lifetime = 30
        
    def update(self):
        self.x += self.vx
        self.y += self.vy
        self.lifetime -= 1
        
    def draw(self, screen):
        if self.lifetime > 0:
            alpha = int(255 * (self.lifetime / 30))
            pygame.draw.circle(screen, (255, alpha, 0), (int(self.x), int(self.y)), 3)

class Game:
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption("飞行躲避游戏")
        self.clock = pygame.time.Clock()
        self.font_large = pygame.font.Font(None, 72)
        self.font_medium = pygame.font.Font(None, 36)
        self.font_small = pygame.font.Font(None, 24)
        
        self.reset_game()
        
    def reset_game(self):
        self.player = Player(SCREEN_WIDTH // 4, SCREEN_HEIGHT // 2)
        self.obstacles = []
        self.powerups = []
        self.particles = []
        self.score = 0
        self.lives = 3
        self.game_over = False
        self.paused = False
        self.invincible = 0  # 无敌帧数
        self.shield_active = False
        self.slow_motion = False
        self.difficulty = 1
        self.obstacle_timer = 0
        self.powerup_timer = 0
        
    def handle_events(self):
        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_SPACE and self.game_over:
                    self.reset_game()
                if event.key == pygame.K_p:
                    self.paused = not self.paused
        return True
    
    def update(self):
        if self.game_over or self.paused:
            return
            
        keys = pygame.key.get_pressed()
        self.player.move(keys)
        
        # 更新无敌状态
        if self.invincible > 0:
            self.invincible -= 1
        if self.shield_active:
            self.shield_active = False  # 单次使用
        
        # 更新慢动作
        time_multiplier = 0.5 if self.slow_motion else 1
        
        # 生成障碍物
        self.obstacle_timer += 1
        spawn_rate = max(20, 40 - self.difficulty * 2)
        if self.obstacle_timer > spawn_rate * (2 if self.slow_motion else 1):
            self.obstacles.append(Obstacle())
            self.obstacle_timer = 0
            
        # 生成道具
        self.powerup_timer += 1
        if self.powerup_timer > 300 and random.random() < 0.02:
            self.powerups.append(PowerUp())
            self.powerup_timer = 0
            
        # 更新障碍物
        for obstacle in self.obstacles[:]:
            obstacle.update()
            if obstacle.off_screen():
                self.obstacles.remove(obstacle)
                self.score += 10  # 成功躲避得分
                
        # 更新道具
        for powerup in self.powerups[:]:
            powerup.update()
            if powerup.off_screen():
                self.powerups.remove(powerup)
                
        # 更新粒子
        for particle in self.particles[:]:
            particle.update()
            if particle.lifetime <= 0:
                self.particles.remove(particle)
                
        # 碰撞检测
        # 玩家与障碍物
        for obstacle in self.obstacles[:]:
            if self.player.get_rect().colliderect(obstacle.get_rect()):
                if self.invincible == 0:
                    if self.shield_active:
                        self.shield_active = False
                        self.obstacles.remove(obstacle)
                    else:
                        self.lives -= 1
                        self.invincible = 60  # 1秒无敌
                        
                        # 添加爆炸粒子效果
                        for _ in range(20):
                            self.particles.append(Particle(self.player.x + self.player.width//2, 
                                                          self.player.y + self.player.height//2))
                        
                        if self.lives <= 0:
                            self.game_over = True
                
        # 玩家与道具
        for powerup in self.powerups[:]:
            if self.player.get_rect().colliderect(powerup.get_rect()):
                if powerup.type == 'shield':
                    self.shield_active = True
                elif powerup.type == 'slow':
                    self.slow_motion = True
                    pygame.time.set_timer(pygame.USEREVENT, 3000)
                elif powerup.type == 'score':
                    self.score += 50
                self.powerups.remove(powerup)
                
        # 处理慢动作结束
        if self.slow_motion:
            # 使用计时器结束慢动作
            pass
            
        # 更新难度
        self.difficulty = 1 + self.score // 1000
        
    def draw(self):
        self.screen.fill(BLACK)
        
        # 绘制星空背景
        for i in range(100):
            pygame.draw.circle(self.screen, WHITE, 
                             (i * 131 % SCREEN_WIDTH, i * 253 % SCREEN_HEIGHT), 1)
        
        # 绘制游戏元素
        self.player.draw(self.screen)
        for obstacle in self.obstacles:
            obstacle.draw(self.screen)
        for powerup in self.powerups:
            powerup.draw(self.screen)
        for particle in self.particles:
            particle.draw(self.screen)
            
        # 绘制UI
        score_text = self.font_medium.render(f"Score: {self.score}", True, WHITE)
        self.screen.blit(score_text, (10, 10))
        
        lives_text = self.font_medium.render(f"Lives: {self.lives}", True, WHITE)
        self.screen.blit(lives_text, (10, 50))
        
        # 无敌闪烁效果
        if self.invincible > 0 and (self.invincible // 5) % 2 == 0:
            shield_text = self.font_small.render("INVINCIBLE!", True, YELLOW)
            self.screen.blit(shield_text, (SCREEN_WIDTH // 2 - 50, 10))
            
        if self.shield_active:
            shield_text = self.font_small.render("SHIELD ACTIVE!", True, GREEN)
            self.screen.blit(shield_text, (SCREEN_WIDTH // 2 - 60, 40))
            
        if self.slow_motion:
            slow_text = self.font_small.render("SLOW MOTION!", True, BLUE)
            self.screen.blit(slow_text, (SCREEN_WIDTH // 2 - 60, 70))
            
        # 显示难度
        diff_text = self.font_small.render(f"Difficulty: {self.difficulty}", True, WHITE)
        self.screen.blit(diff_text, (10, 90))
        
        # 游戏结束画面
        if self.game_over:
            overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
            overlay.set_alpha(128)
            overlay.fill(BLACK)
            self.screen.blit(overlay, (0, 0))
            
            game_over_text = self.font_large.render("GAME OVER", True, RED)
            text_rect = game_over_text.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2 - 50))
            self.screen.blit(game_over_text, text_rect)
            
            final_score = self.font_medium.render(f"Final Score: {self.score}", True, WHITE)
            score_rect = final_score.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2))
            self.screen.blit(final_score, score_rect)
            
            restart_text = self.font_medium.render("Press SPACE to Restart", True, GREEN)
            restart_rect = restart_text.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2 + 50))
            self.screen.blit(restart_text, restart_rect)
            
        # 暂停画面
        elif self.paused:
            pause_text = self.font_large.render("PAUSED", True, WHITE)
            text_rect = pause_text.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT//2))
            self.screen.blit(pause_text, text_rect)
            
        pygame.display.flip()
        
    def run(self):
        running = True
        while running:
            running = self.handle_events()
            self.update()
            self.draw()
            self.clock.tick(FPS)
            
        pygame.quit()
        sys.exit()

def main():
    game = Game()
    game.run()

if __name__ == "__main__":
    main()