import pygame
import random
import math
import sys
from enum import Enum

# 初始化pygame
pygame.init()

# 设置中文字体


def get_chinese_font(size):
    # 尝试使用常见的中文字体
    chinese_fonts = [
        "SimHei",          # 黑体
        "Microsoft YaHei",  # 微软雅黑
        "SimSun",          # 宋体
        "NSimSun",         # 新宋体
        "FangSong",        # 仿宋
        "KaiTi",           # 楷体
        "STKaiti",         # 华文楷体
        "STXihei",         # 华文细黑
        "STHeiti",         # 华文黑体
        "STSong",          # 华文宋体
        "Arial Unicode MS",
        "WenQuanYi Zen Hei"  # 文泉驿正黑
    ]

    for font_name in chinese_fonts:
        try:
            return pygame.font.SysFont(font_name, size)
        except:
            continue

    # 如果都没有找到，使用默认字体
    return pygame.font.Font(None, size)


# 游戏窗口设置
WIDTH, HEIGHT = 1000, 700
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("🚀 星际射手 | 太空冒险")
clock = pygame.time.Clock()

# 颜色定义


class Colors:
    BLACK = (0, 0, 0)
    WHITE = (255, 255, 255)
    RED = (255, 50, 50)
    GREEN = (50, 255, 100)
    BLUE = (50, 150, 255)
    YELLOW = (255, 255, 50)
    PURPLE = (180, 70, 255)
    ORANGE = (255, 150, 50)
    CYAN = (0, 200, 255)
    DARK_BLUE = (20, 30, 60)
    SPACE_BLUE = (10, 20, 40)
    UI_BG = (30, 30, 50, 180)

# 敌人类型枚举


class EnemyType(Enum):
    BASIC = 1
    FAST = 2
    TANK = 3
    SHOOTER = 4
    BOSS = 5

# 粒子效果类


class Particle:
    def __init__(self, x, y, color, size=3, speed=2, lifetime=30):
        self.x = x
        self.y = y
        self.color = color
        self.size = size
        angle = random.uniform(0, math.pi * 2)
        self.vx = math.cos(angle) * random.uniform(0.5, speed)
        self.vy = math.sin(angle) * random.uniform(0.5, speed)
        self.lifetime = lifetime
        self.max_lifetime = lifetime

    def update(self):
        self.x += self.vx
        self.y += self.vy
        self.lifetime -= 1
        self.size *= 0.95
        return self.lifetime > 0 and self.size > 0.5

    def draw(self, surface):
        alpha = int(255 * (self.lifetime / self.max_lifetime))
        s = pygame.Surface(
            (int(self.size*2), int(self.size*2)), pygame.SRCALPHA)
        pygame.draw.circle(s, (*self.color, alpha),
                           (int(self.size), int(self.size)), int(self.size))
        surface.blit(s, (int(self.x - self.size), int(self.y - self.size)))

# 爆炸效果


class Explosion:
    def __init__(self, x, y, size=30, color=Colors.ORANGE):
        self.x = x
        self.y = y
        self.size = size
        self.color = color
        self.particles = []
        for _ in range(20):
            self.particles.append(
                Particle(x, y, color, random.uniform(2, 5), random.uniform(1, 3)))
        self.lifetime = 45

    def update(self):
        self.particles = [p for p in self.particles if p.update()]
        self.lifetime -= 1
        return len(self.particles) > 0 or self.lifetime > 0

    def draw(self, surface):
        for particle in self.particles:
            particle.draw(surface)

        # 爆炸光晕
        if self.lifetime > 0:
            alpha = int(100 * (self.lifetime / 45))
            s = pygame.Surface((self.size*4, self.size*4), pygame.SRCALPHA)
            pygame.draw.circle(s, (*self.color, alpha),
                               (self.size*2, self.size*2), self.size*2)
            surface.blit(s, (self.x - self.size*2, self.y - self.size*2))

# 玩家类


class Player:
    def __init__(self):
        self.x = WIDTH // 2
        self.y = HEIGHT - 100
        self.radius = 25
        self.speed = 6
        self.health = 100
        self.max_health = 100
        self.score = 0
        self.level = 1
        self.kills = 0
        self.shoot_cooldown = 0
        self.shoot_delay = 15
        self.color = Colors.CYAN
        self.trail = []
        self.invincible = 0
        self.weapon_level = 1
        self.weapon_cooldown = 0
        self.special_cooldown = 0

    def move(self, keys, mouse_pos=None):
        # 键盘控制
        if keys[pygame.K_a] or keys[pygame.K_LEFT]:
            self.x -= self.speed
        if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
            self.x += self.speed
        if keys[pygame.K_w] or keys[pygame.K_UP]:
            self.y -= self.speed
        if keys[pygame.K_s] or keys[pygame.K_DOWN]:
            self.y += self.speed

        # 鼠标控制
        if mouse_pos:
            self.x += (mouse_pos[0] - self.x) * 0.1
            self.y += (mouse_pos[1] - self.y) * 0.1

        # 边界限制
        self.x = max(self.radius, min(WIDTH - self.radius, self.x))
        self.y = max(self.radius, min(HEIGHT - self.radius, self.y))

        # 拖尾效果
        self.trail.append((self.x, self.y))
        if len(self.trail) > 10:
            self.trail.pop(0)

        # 冷却减少
        if self.shoot_cooldown > 0:
            self.shoot_cooldown -= 1
        if self.weapon_cooldown > 0:
            self.weapon_cooldown -= 1
        if self.special_cooldown > 0:
            self.special_cooldown -= 1
        if self.invincible > 0:
            self.invincible -= 1

    def shoot(self, bullets, is_mouse_click=False, mouse_pos=None):
        if self.shoot_cooldown > 0:
            return False

        self.shoot_cooldown = self.shoot_delay

        if is_mouse_click and mouse_pos:
            # 鼠标射击：向鼠标位置发射子弹
            dx = mouse_pos[0] - self.x
            dy = mouse_pos[1] - self.y
            dist = max(0.1, math.sqrt(dx*dx + dy*dy))
            vx = (dx / dist) * 10
            vy = (dy / dist) * 10
            bullets.append(PlayerBullet(self.x, self.y, vx, vy, Colors.YELLOW))
        else:
            # 键盘射击：向上发射
            if self.weapon_level == 1:
                bullets.append(PlayerBullet(
                    self.x, self.y, 0, -10, Colors.YELLOW))
            elif self.weapon_level == 2:
                bullets.append(PlayerBullet(
                    self.x - 10, self.y, 0, -10, Colors.YELLOW))
                bullets.append(PlayerBullet(
                    self.x + 10, self.y, 0, -10, Colors.YELLOW))
            elif self.weapon_level >= 3:
                bullets.append(PlayerBullet(
                    self.x, self.y, 0, -10, Colors.YELLOW))
                bullets.append(PlayerBullet(
                    self.x - 15, self.y, -1, -9, Colors.YELLOW))
                bullets.append(PlayerBullet(
                    self.x + 15, self.y, 1, -9, Colors.YELLOW))

        return True

    def use_special_weapon(self, bullets):
        if self.special_cooldown > 0:
            return False

        self.special_cooldown = 150  # 15秒冷却

        # 发射一圈子弹
        for i in range(12):
            angle = (i * 30) * math.pi / 180
            vx = math.cos(angle) * 8
            vy = math.sin(angle) * 8
            bullets.append(PlayerBullet(self.x, self.y, vx, vy,
                           Colors.PURPLE, size=8, damage=3))

        return True

    def take_damage(self, damage):
        if self.invincible > 0:
            return
        self.health -= damage
        self.invincible = 30
        return self.health <= 0

    def get_rect(self):
        """获取玩家的碰撞矩形"""
        return pygame.Rect(self.x - self.radius, self.y - self.radius,
                           self.radius * 2, self.radius * 2)

    def draw(self, surface):
        # 绘制拖尾
        for i, (trail_x, trail_y) in enumerate(self.trail):
            alpha = int(255 * (i / len(self.trail)))
            size = self.radius * (i / len(self.trail)) * 0.7
            s = pygame.Surface((int(size*2), int(size*2)), pygame.SRCALPHA)
            pygame.draw.circle(s, (*self.color, alpha),
                               (int(size), int(size)), int(size))
            surface.blit(s, (trail_x - size, trail_y - size))

        # 绘制玩家
        if self.invincible == 0 or self.invincible % 4 < 2:
            pygame.draw.circle(surface, self.color,
                               (int(self.x), int(self.y)), self.radius)
            pygame.draw.circle(surface, Colors.WHITE,
                               (int(self.x), int(self.y)), self.radius, 2)

            # 绘制玩家细节
            pygame.draw.circle(surface, Colors.BLUE,
                               (int(self.x), int(self.y-5)), 8)
            pygame.draw.circle(surface, Colors.WHITE,
                               (int(self.x-3), int(self.y-7)), 2)
            pygame.draw.circle(surface, Colors.WHITE,
                               (int(self.x+3), int(self.y-7)), 2)

            # 绘制武器
            if self.weapon_level >= 2:
                pygame.draw.rect(surface, Colors.YELLOW,
                                 (int(self.x-20), int(self.y-5), 40, 10))

        # 绘制能量护盾（无敌时）
        if self.invincible > 0:
            alpha = int(100 + 155 * ((30 - self.invincible) / 30))
            s = pygame.Surface((self.radius*4, self.radius*4), pygame.SRCALPHA)
            pygame.draw.circle(s, (*Colors.CYAN, alpha),
                               (self.radius*2, self.radius*2), self.radius*2, 3)
            surface.blit(s, (self.x - self.radius*2, self.y - self.radius*2))

# 玩家子弹类


class PlayerBullet:
    def __init__(self, x, y, vx, vy, color=Colors.YELLOW, size=6, damage=1):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.radius = size
        self.color = color
        self.damage = damage

    def update(self):
        self.x += self.vx
        self.y += self.vy
        return 0 <= self.x <= WIDTH and 0 <= self.y <= HEIGHT

    def draw(self, surface):
        pygame.draw.circle(surface, self.color,
                           (int(self.x), int(self.y)), self.radius)
        pygame.draw.circle(surface, Colors.WHITE,
                           (int(self.x), int(self.y)), self.radius, 1)

        # 子弹光效
        for i in range(3):
            trail_size = self.radius * (i+1) * 0.3
            alpha = 100 - i*30
            s = pygame.Surface(
                (int(trail_size*2), int(trail_size*2)), pygame.SRCALPHA)
            pygame.draw.circle(
                s, (*self.color, alpha), (int(trail_size), int(trail_size)), int(trail_size))
            surface.blit(s, (int(self.x - self.vx*(i+1) - trail_size),
                         int(self.y - self.vy*(i+1) - trail_size)))

    def get_rect(self):
        return pygame.Rect(self.x - self.radius, self.y - self.radius,
                           self.radius*2, self.radius*2)

# 敌人类


class Enemy:
    def __init__(self, enemy_type=EnemyType.BASIC, level=1):
        self.type = enemy_type

        if enemy_type == EnemyType.BASIC:
            self.radius = 20
            self.speed = random.uniform(1, 2)
            self.health = 30
            self.color = Colors.RED
            self.score_value = 10
        elif enemy_type == EnemyType.FAST:
            self.radius = 15
            self.speed = random.uniform(3, 4)
            self.health = 20
            self.color = Colors.ORANGE
            self.score_value = 15
        elif enemy_type == EnemyType.TANK:
            self.radius = 35
            self.speed = random.uniform(0.5, 1)
            self.health = 100
            self.color = Colors.PURPLE
            self.score_value = 30
        elif enemy_type == EnemyType.SHOOTER:
            self.radius = 25
            self.speed = random.uniform(1, 1.5)
            self.health = 40
            self.color = Colors.GREEN
            self.score_value = 20
            self.shoot_timer = random.randint(60, 120)
        elif enemy_type == EnemyType.BOSS:
            self.radius = 60
            self.speed = 0.3
            self.health = 500
            self.color = (255, 50, 50)
            self.score_value = 100
            self.shoot_timer = 30

        self.x = random.randint(self.radius, WIDTH - self.radius)
        self.y = -self.radius
        self.max_health = self.health
        self.level = level
        self.health += (level - 1) * 20
        self.max_health = self.health

        # 添加粒子效果
        self.particles = []

    def update(self, player_x, player_y, enemy_bullets=None):
        # 向玩家移动
        dx = player_x - self.x
        dy = player_y - self.y
        dist = max(0.1, math.sqrt(dx*dx + dy*dy))
        self.x += (dx / dist) * self.speed
        self.y += (dy / dist) * self.speed

        # 射击者敌人
        if self.type in [EnemyType.SHOOTER, EnemyType.BOSS]:
            self.shoot_timer -= 1
            if self.shoot_timer <= 0 and enemy_bullets is not None:
                self.shoot_timer = 120 if self.type == EnemyType.SHOOTER else 30
                dx = player_x - self.x
                dy = player_y - self.y
                dist = max(0.1, math.sqrt(dx*dx + dy*dy))
                vx = (dx / dist) * 5
                vy = (dy / dist) * 5
                enemy_bullets.append(EnemyBullet(
                    self.x, self.y, vx, vy, Colors.RED))

        # 粒子效果
        if random.random() < 0.3:
            self.particles.append(Particle(
                self.x + random.uniform(-5, 5),
                self.y + random.uniform(-5, 5),
                self.color, 2, 0.5, 20))

        self.particles = [p for p in self.particles if p.update()]

        return self.y < HEIGHT + self.radius

    def take_damage(self, damage):
        self.health -= damage

        # 受伤粒子效果
        for _ in range(5):
            self.particles.append(Particle(
                self.x + random.uniform(-5, 5),
                self.y + random.uniform(-5, 5),
                Colors.YELLOW, 3, 1, 15))

        return self.health <= 0

    def get_rect(self):
        return pygame.Rect(self.x - self.radius, self.y - self.radius,
                           self.radius*2, self.radius*2)

    def draw(self, surface):
        # 绘制粒子
        for particle in self.particles:
            particle.draw(surface)

        # 绘制敌人
        pygame.draw.circle(surface, self.color,
                           (int(self.x), int(self.y)), self.radius)
        pygame.draw.circle(surface, Colors.WHITE,
                           (int(self.x), int(self.y)), self.radius, 2)

        # 敌人细节
        if self.type == EnemyType.BASIC:
            pygame.draw.circle(surface, Colors.BLACK,
                               (int(self.x), int(self.y)), 8)
        elif self.type == EnemyType.FAST:
            for angle in [0, 120, 240]:
                rx = math.cos(math.radians(angle)) * 10
                ry = math.sin(math.radians(angle)) * 10
                pygame.draw.circle(surface, Colors.WHITE,
                                   (int(self.x + rx), int(self.y + ry)), 5)
        elif self.type == EnemyType.TANK:
            pygame.draw.rect(surface, Colors.DARK_BLUE,
                             (int(self.x-15), int(self.y-5), 30, 10))
        elif self.type == EnemyType.SHOOTER:
            pygame.draw.circle(surface, Colors.YELLOW,
                               (int(self.x), int(self.y)), 10)

        # 绘制血条
        if self.health < self.max_health:
            bar_width = 40
            bar_height = 6
            health_ratio = self.health / self.max_health
            pygame.draw.rect(surface, Colors.RED,
                             (int(self.x - bar_width//2), int(self.y - self.radius - 10),
                              bar_width, bar_height))
            pygame.draw.rect(surface, Colors.GREEN,
                             (int(self.x - bar_width//2), int(self.y - self.radius - 10),
                              int(bar_width * health_ratio), bar_height))

# 敌人子弹类


class EnemyBullet:
    def __init__(self, x, y, vx, vy, color=Colors.RED):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.radius = 5
        self.color = color

    def update(self):
        self.x += self.vx
        self.y += self.vy
        return 0 <= self.x <= WIDTH and 0 <= self.y <= HEIGHT

    def draw(self, surface):
        pygame.draw.circle(surface, self.color,
                           (int(self.x), int(self.y)), self.radius)
        pygame.draw.circle(surface, Colors.WHITE,
                           (int(self.x), int(self.y)), self.radius, 1)

    def get_rect(self):
        return pygame.Rect(self.x - self.radius, self.y - self.radius,
                           self.radius*2, self.radius*2)

# 道具类


class PowerUp:
    def __init__(self, x, y, ptype="health"):
        self.x = x
        self.y = y
        self.radius = 15
        self.type = ptype
        self.speed = 2
        self.color = {
            "health": Colors.RED,
            "weapon": Colors.YELLOW,
            "shield": Colors.BLUE
        }.get(ptype, Colors.WHITE)

    def update(self):
        self.y += self.speed
        return self.y < HEIGHT + self.radius

    def draw(self, surface):
        # 绘制光晕
        s = pygame.Surface((self.radius*4, self.radius*4), pygame.SRCALPHA)
        pygame.draw.circle(s, (*self.color, 100),
                           (self.radius*2, self.radius*2), self.radius*2)
        surface.blit(s, (self.x - self.radius*2, self.y - self.radius*2))

        # 绘制道具
        pygame.draw.circle(surface, self.color,
                           (int(self.x), int(self.y)), self.radius)
        pygame.draw.circle(surface, Colors.WHITE,
                           (int(self.x), int(self.y)), self.radius, 2)

        # 绘制符号
        font = get_chinese_font(20)
        symbol = "❤" if self.type == "health" else "⚡" if self.type == "weapon" else "🛡"
        try:
            text = font.render(symbol, True, Colors.WHITE)
            surface.blit(text, (int(self.x - text.get_width()//2),
                         int(self.y - text.get_height()//2)))
        except:
            # 如果特殊字符显示失败，使用字母
            symbol = "H" if self.type == "health" else "W" if self.type == "weapon" else "S"
            text = font.render(symbol, True, Colors.WHITE)
            surface.blit(text, (int(self.x - text.get_width()//2),
                         int(self.y - text.get_height()//2)))

    def get_rect(self):
        return pygame.Rect(self.x - self.radius, self.y - self.radius,
                           self.radius*2, self.radius*2)

# 游戏UI类


class GameUI:
    def __init__(self):
        self.font_large = get_chinese_font(48)
        self.font_medium = get_chinese_font(36)
        self.font_small = get_chinese_font(24)
        self.font_tiny = get_chinese_font(20)

    def draw_health_bar(self, surface, player):
        # 生命条背景
        bar_width = 200
        bar_height = 20
        bar_x = 20
        bar_y = 20

        # 绘制背景
        pygame.draw.rect(surface, (50, 50, 50), (bar_x, bar_y,
                         bar_width, bar_height), border_radius=10)

        # 绘制生命条
        health_ratio = player.health / player.max_health
        health_width = int(bar_width * health_ratio)

        # 渐变颜色
        if health_ratio > 0.7:
            color = Colors.GREEN
        elif health_ratio > 0.3:
            color = Colors.YELLOW
        else:
            color = Colors.RED

        pygame.draw.rect(surface, color, (bar_x, bar_y,
                         health_width, bar_height), border_radius=10)

        # 边框
        pygame.draw.rect(surface, Colors.WHITE, (bar_x, bar_y,
                         bar_width, bar_height), 2, border_radius=10)

        # 生命值文字
        health_text = self.font_tiny.render(
            f"{player.health}/{player.max_health}", True, Colors.WHITE)
        surface.blit(health_text, (bar_x + bar_width//2 - health_text.get_width()//2,
                                   bar_y + bar_height//2 - health_text.get_height()//2))

        # 生命图标
        try:
            heart_text = self.font_tiny.render("❤", True, Colors.RED)
            surface.blit(heart_text, (bar_x - 25, bar_y))
        except:
            heart_text = self.font_tiny.render("HP", True, Colors.RED)
            surface.blit(heart_text, (bar_x - 30, bar_y))

    def draw_score(self, surface, player):
        score_bg = pygame.Surface((200, 60), pygame.SRCALPHA)
        score_bg.fill((*Colors.UI_BG[:3], 200))
        surface.blit(score_bg, (WIDTH - 220, 20))

        # 分数
        score_text = self.font_small.render(
            f"分数: {player.score}", True, Colors.YELLOW)
        surface.blit(score_text, (WIDTH - 210, 30))

        # 等级
        level_text = self.font_small.render(
            f"等级: {player.level}", True, Colors.CYAN)
        surface.blit(level_text, (WIDTH - 210, 70))

        # 击杀
        kills_text = self.font_small.render(
            f"击杀: {player.kills}", True, Colors.GREEN)
        surface.blit(kills_text, (WIDTH - 210, 95))

    def draw_weapon_info(self, surface, player):
        weapon_bg = pygame.Surface((200, 100), pygame.SRCALPHA)
        weapon_bg.fill((*Colors.UI_BG[:3], 200))
        surface.blit(weapon_bg, (20, HEIGHT - 120))

        # 武器等级
        weapon_text = self.font_small.render("武器等级:", True, Colors.WHITE)
        surface.blit(weapon_text, (30, HEIGHT - 110))

        # 武器等级显示
        for i in range(3):
            color = Colors.YELLOW if i < player.weapon_level else (
                100, 100, 100)
            pygame.draw.rect(surface, color, (40 + i*40, HEIGHT - 85, 30, 10))

        # 特殊武器冷却
        if player.special_cooldown > 0:
            cooldown_ratio = player.special_cooldown / 150
            pygame.draw.rect(surface, Colors.PURPLE,
                             (30, HEIGHT - 60, 120, 20))
            pygame.draw.rect(surface, Colors.DARK_BLUE,
                             (30, HEIGHT - 60, int(120 * cooldown_ratio), 20))
        else:
            pygame.draw.rect(surface, Colors.PURPLE,
                             (30, HEIGHT - 60, 120, 20))

        special_text = self.font_small.render("特殊武器", True, Colors.WHITE)
        surface.blit(special_text, (50, HEIGHT - 55))

    def draw_controls(self, surface):
        controls = [
            ("WASD/方向键", "移动"),
            ("鼠标", "移动/瞄准"),
            ("左键/空格", "射击"),
            ("Q键", "特殊武器"),
            ("ESC", "暂停"),
            ("R键", "重新开始")
        ]

        controls_bg = pygame.Surface((200, 180), pygame.SRCALPHA)
        controls_bg.fill((*Colors.UI_BG[:3], 150))
        surface.blit(controls_bg, (WIDTH - 220, HEIGHT - 200))

        title = self.font_small.render("控制说明:", True, Colors.CYAN)
        surface.blit(title, (WIDTH - 210, HEIGHT - 195))

        for i, (key, action) in enumerate(controls):
            key_text = self.font_tiny.render(key, True, Colors.YELLOW)
            action_text = self.font_tiny.render(action, True, Colors.WHITE)
            surface.blit(key_text, (WIDTH - 210, HEIGHT - 165 + i*25))
            surface.blit(action_text, (WIDTH - 120, HEIGHT - 165 + i*25))

    def draw_game_over(self, surface, player, game_over):
        if not game_over:
            return

        overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 180))
        surface.blit(overlay, (0, 0))

        # 游戏结束文字
        game_over_text = self.font_large.render("游戏结束!", True, Colors.RED)
        surface.blit(game_over_text, (WIDTH//2 -
                     game_over_text.get_width()//2, HEIGHT//2 - 100))

        # 最终分数
        score_text = self.font_medium.render(
            f"最终分数: {player.score}", True, Colors.YELLOW)
        surface.blit(
            score_text, (WIDTH//2 - score_text.get_width()//2, HEIGHT//2 - 30))

        # 重新开始提示
        restart_text = self.font_medium.render("按 R 键重新开始", True, Colors.GREEN)
        surface.blit(restart_text, (WIDTH//2 -
                     restart_text.get_width()//2, HEIGHT//2 + 30))

        # 击杀统计
        kills_text = self.font_small.render(
            f"击杀敌人: {player.kills}", True, Colors.CYAN)
        surface.blit(
            kills_text, (WIDTH//2 - kills_text.get_width()//2, HEIGHT//2 + 80))

    def draw_pause_screen(self, surface, paused):
        if not paused:
            return

        overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 150))
        surface.blit(overlay, (0, 0))

        pause_text = self.font_large.render("游戏暂停", True, Colors.YELLOW)
        surface.blit(
            pause_text, (WIDTH//2 - pause_text.get_width()//2, HEIGHT//2 - 50))

        continue_text = self.font_medium.render(
            "按 ESC 继续游戏", True, Colors.WHITE)
        surface.blit(continue_text, (WIDTH//2 -
                     continue_text.get_width()//2, HEIGHT//2 + 20))

# 绘制星空背景


def draw_stars(surface, stars):
    for star in stars:
        size = star[2]
        brightness = min(
            255, 100 + int(abs(math.sin(pygame.time.get_ticks() * 0.001 + star[3])) * 155))
        color = (brightness, brightness, brightness)
        pygame.draw.circle(surface, color, (int(star[0]), int(star[1])), size)

# 主游戏函数


def main():
    # 创建游戏对象
    player = Player()
    bullets = []
    enemy_bullets = []
    enemies = []
    explosions = []
    powerups = []
    game_ui = GameUI()

    # 游戏状态
    game_over = False
    paused = False
    spawn_timer = 0
    level_up_timer = 0
    wave = 1
    enemies_in_wave = 5

    # 星空背景
    stars = [(random.randint(0, WIDTH), random.randint(0, HEIGHT),
              random.uniform(1, 3), random.uniform(0, math.pi*2))
             for _ in range(200)]

    # 主游戏循环
    running = True
    mouse_control = False

    while running:
        mouse_pos = pygame.mouse.get_pos()

        # 事件处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    paused = not paused

                elif event.key == pygame.K_SPACE and not game_over and not paused:
                    player.shoot(bullets)

                elif event.key == pygame.K_q and not game_over and not paused:
                    player.use_special_weapon(bullets)

                elif event.key == pygame.K_r and game_over:
                    # 重新开始游戏
                    player = Player()
                    bullets = []
                    enemy_bullets = []
                    enemies = []
                    explosions = []
                    powerups = []
                    game_over = False
                    spawn_timer = 0
                    wave = 1
                    enemies_in_wave = 5

                elif event.key == pygame.K_m:
                    mouse_control = not mouse_control

            elif event.type == pygame.MOUSEBUTTONDOWN and not game_over and not paused:
                if event.button == 1:  # 左键
                    player.shoot(bullets, True, mouse_pos)

        if not paused and not game_over:
            # 控制玩家
            keys = pygame.key.get_pressed()
            player.move(keys, mouse_pos if mouse_control else None)

            # 生成敌人
            spawn_timer += 1
            if spawn_timer >= 60:  # 每秒生成
                spawn_timer = 0
                if len(enemies) < enemies_in_wave:
                    # 根据波数选择敌人类型
                    if wave <= 2:
                        enemy_type = EnemyType.BASIC
                    elif wave <= 4:
                        enemy_type = random.choice(
                            [EnemyType.BASIC, EnemyType.FAST])
                    elif wave <= 6:
                        enemy_type = random.choice(
                            [EnemyType.BASIC, EnemyType.FAST, EnemyType.TANK])
                    else:
                        enemy_type = random.choice([EnemyType.BASIC, EnemyType.FAST,
                                                   EnemyType.TANK, EnemyType.SHOOTER])

                    enemies.append(Enemy(enemy_type, wave))

                # 如果所有敌人都被消灭，进入下一波
                if len(enemies) == 0:
                    wave += 1
                    enemies_in_wave = 5 + wave * 2

                    # 每3波生成一个BOSS
                    if wave % 3 == 0:
                        enemies.append(Enemy(EnemyType.BOSS, wave))

            # 更新子弹
            bullets = [bullet for bullet in bullets if bullet.update()]

            # 更新敌人子弹
            enemy_bullets = [
                bullet for bullet in enemy_bullets if bullet.update()]

            # 更新敌人
            for enemy in enemies[:]:
                if not enemy.update(player.x, player.y, enemy_bullets):
                    enemies.remove(enemy)

            # 更新爆炸效果
            explosions = [
                explosion for explosion in explosions if explosion.update()]

            # 更新道具
            powerups = [powerup for powerup in powerups if powerup.update()]

            # 碰撞检测：子弹 vs 敌人
            for bullet in bullets[:]:
                bullet_rect = bullet.get_rect()
                for enemy in enemies[:]:
                    if bullet_rect.colliderect(enemy.get_rect()):
                        if bullet in bullets:
                            bullets.remove(bullet)

                        if enemy.take_damage(bullet.damage):
                            # 敌人被消灭
                            enemies.remove(enemy)
                            explosions.append(
                                Explosion(enemy.x, enemy.y, enemy.radius, enemy.color))
                            player.score += enemy.score_value
                            player.kills += 1

                            # 升级检查
                            level_up_timer += 1
                            if level_up_timer >= 10:  # 每10个敌人升级一次
                                level_up_timer = 0
                                player.level += 1
                                if player.weapon_level < 3:
                                    player.weapon_level += 1

                            # 随机掉落道具
                            if random.random() < 0.3:
                                powerup_type = random.choice(
                                    ["health", "weapon", "shield"])
                                powerups.append(
                                    PowerUp(enemy.x, enemy.y, powerup_type))

                        break

            # 碰撞检测：玩家 vs 敌人子弹
            player_rect = player.get_rect()
            for bullet in enemy_bullets[:]:
                if player_rect.colliderect(bullet.get_rect()):
                    enemy_bullets.remove(bullet)
                    if player.take_damage(10):
                        game_over = True
                        explosions.append(
                            Explosion(player.x, player.y, 50, player.color))

            # 碰撞检测：玩家 vs 敌人
            for enemy in enemies[:]:
                if player_rect.colliderect(enemy.get_rect()):
                    enemies.remove(enemy)
                    explosions.append(
                        Explosion(enemy.x, enemy.y, enemy.radius, enemy.color))
                    if player.take_damage(20):
                        game_over = True
                        explosions.append(
                            Explosion(player.x, player.y, 50, player.color))

            # 碰撞检测：玩家 vs 道具
            for powerup in powerups[:]:
                if player_rect.colliderect(powerup.get_rect()):
                    if powerup.type == "health":
                        player.health = min(
                            player.max_health, player.health + 30)
                    elif powerup.type == "weapon":
                        player.weapon_level = min(3, player.weapon_level + 1)
                    elif powerup.type == "shield":
                        player.invincible = 180  # 3秒无敌

                    powerups.remove(powerup)
                    explosions.append(
                        Explosion(powerup.x, powerup.y, 20, powerup.color))

        # 绘制
        screen.fill(Colors.SPACE_BLUE)

        # 绘制背景
        draw_stars(screen, stars)

        # 绘制远处的星球
        for i in range(3):
            planet_x = 200 + i * 300
            planet_y = 150
            planet_radius = 50 + i * 20
            planet_color = (100 - i*20, 100 - i*20, 150 + i*30)

            s = pygame.Surface(
                (planet_radius*2, planet_radius*2), pygame.SRCALPHA)
            pygame.draw.circle(s, (*planet_color, 100),
                               (planet_radius, planet_radius), planet_radius)
            screen.blit(s, (planet_x - planet_radius,
                        planet_y - planet_radius))

        # 绘制游戏对象
        for powerup in powerups:
            powerup.draw(screen)

        for explosion in explosions:
            explosion.draw(screen)

        for bullet in enemy_bullets:
            bullet.draw(screen)

        for bullet in bullets:
            bullet.draw(screen)

        for enemy in enemies:
            enemy.draw(screen)

        player.draw(screen)

        # 绘制UI
        game_ui.draw_health_bar(screen, player)
        game_ui.draw_score(screen, player)
        game_ui.draw_weapon_info(screen, player)
        game_ui.draw_controls(screen)

        # 绘制波数
        try:
            wave_text = game_ui.font_medium.render(
                f"波数: {wave}", True, Colors.ORANGE)
            screen.blit(wave_text, (WIDTH//2 - wave_text.get_width()//2, 20))
        except:
            wave_text = get_chinese_font(36).render(
                f"Wave: {wave}", True, Colors.ORANGE)
            screen.blit(wave_text, (WIDTH//2 - wave_text.get_width()//2, 20))

        # 控制模式提示
        control_mode = "鼠标控制" if mouse_control else "键盘控制"
        try:
            mode_text = game_ui.font_tiny.render(
                f"控制模式: {control_mode} (按M切换)", True, Colors.WHITE)
            screen.blit(
                mode_text, (WIDTH//2 - mode_text.get_width()//2, HEIGHT - 30))
        except:
            mode_text = get_chinese_font(20).render(
                f"Control: {control_mode} (M to switch)", True, Colors.WHITE)
            screen.blit(
                mode_text, (WIDTH//2 - mode_text.get_width()//2, HEIGHT - 30))

        # 游戏状态界面
        game_ui.draw_game_over(screen, player, game_over)
        game_ui.draw_pause_screen(screen, paused)

        # 更新显示
        pygame.display.flip()
        clock.tick(60)

    pygame.quit()
    sys.exit()


if __name__ == "__main__":
    main()
