import pygame
import sys
import random
import math
import time

# 初始化pygame
pygame.init()

# 游戏窗口设置
SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 700
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("星空射手")
clock = pygame.time.Clock()
FPS = 60

# 颜色定义
BACKGROUND_COLOR = (10, 15, 30)
STAR_COLOR = (255, 255, 255)
PLAYER_COLOR = (0, 200, 255)
BULLET_COLOR = (255, 255, 100)
ENEMY_COLOR = (255, 100, 100)
EXPLOSION_COLOR = (255, 150, 50)
POWERUP_COLOR = (100, 255, 100)
TEXT_COLOR = (255, 255, 255)
TEXT_WHITE = (255, 255, 255)  # 修复：添加TEXT_WHITE定义
TEXT_SHADOW = (0, 0, 0)
NEON_BLUE = (0, 200, 255)
NEON_GREEN = (0, 255, 100)
NEON_RED = (255, 0, 100)
NEON_PURPLE = (200, 0, 255)
NEON_YELLOW = (255, 255, 0)

# 创建字体
try:
    font_small = pygame.font.Font(None, 24)
    font_medium = pygame.font.Font(None, 36)
    font_large = pygame.font.Font(None, 48)
    font_huge = pygame.font.Font(None, 64)
except:
    font_small = pygame.font.SysFont(None, 24)
    font_medium = pygame.font.SysFont(None, 36)
    font_large = pygame.font.SysFont(None, 48)
    font_huge = pygame.font.SysFont(None, 64)

# 玩家类
class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 40
        self.height = 40
        self.speed = 5
        self.health = 100
        self.bullets = []
        self.last_shot = 0
        self.shoot_delay = 200  # 毫秒
        
    def update(self, keys):
        # 移动控制
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            self.x -= self.speed
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            self.x += self.speed
        if keys[pygame.K_UP] or keys[pygame.K_w]:
            self.y -= self.speed
        if keys[pygame.K_DOWN] or keys[pygame.K_s]:
            self.y += self.speed
            
        # 屏幕边界限制
        self.x = max(0, min(SCREEN_WIDTH - self.width, self.x))
        self.y = max(0, min(SCREEN_HEIGHT - self.height, self.y))
        
        # 射击控制
        current_time = pygame.time.get_ticks()
        if keys[pygame.K_SPACE] and current_time - self.last_shot > self.shoot_delay:
            self.shoot()
            self.last_shot = current_time
            
        # 更新子弹
        for bullet in self.bullets[:]:
            bullet.update()
            if bullet.y < 0 or bullet.y > SCREEN_HEIGHT or bullet.x < 0 or bullet.x > SCREEN_WIDTH:
                self.bullets.remove(bullet)
                
    def shoot(self):
        bullet = Bullet(self.x + self.width//2, self.y)
        self.bullets.append(bullet)
        
    def draw(self, surface):
        # 绘制玩家
        pygame.draw.rect(surface, PLAYER_COLOR, (self.x, self.y, self.width, self.height))
        
        # 绘制子弹
        for bullet in self.bullets:
            bullet.draw(surface)
            
    def get_rect(self):
        return pygame.Rect(self.x, self.y, self.width, self.height)

# 子弹类
class Bullet:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 4
        self.height = 10
        self.speed = 8
        
    def update(self):
        self.y -= self.speed
        
    def draw(self, surface):
        pygame.draw.rect(surface, BULLET_COLOR, (self.x, self.y, self.width, self.height))
        
    def get_rect(self):
        return pygame.Rect(self.x, self.y, self.width, self.height)

# 敌人类
class Enemy:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 40
        self.height = 40
        self.speed = 2
        self.health = 3
        self.bullets = []
        self.shoot_timer = 0
        
    def update(self):
        self.y += self.speed
        
        # 随机射击
        self.shoot_timer += 1
        if self.shoot_timer > 100 and random.random() < 0.01:
            self.shoot()
            self.shoot_timer = 0
            
        # 更新子弹
        for bullet in self.bullets[:]:
            bullet.update()
            if bullet.y > SCREEN_HEIGHT:
                self.bullets.remove(bullet)
                
    def shoot(self):
        bullet = EnemyBullet(self.x + self.width//2, self.y + self.height)
        self.bullets.append(bullet)
        
    def draw(self, surface):
        pygame.draw.rect(surface, ENEMY_COLOR, (self.x, self.y, self.width, self.height))
        
        for bullet in self.bullets:
            bullet.draw(surface)
            
    def get_rect(self):
        return pygame.Rect(self.x, self.y, self.width, self.height)

# 敌人子弹类
class EnemyBullet:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 4
        self.height = 10
        self.speed = 5
        
    def update(self):
        self.y += self.speed
        
    def draw(self, surface):
        pygame.draw.rect(surface, (255, 50, 50), (self.x, self.y, self.width, self.height))
        
    def get_rect(self):
        return pygame.Rect(self.x, self.y, self.width, self.height)

# 游戏主类
class ShootingGame:
    def __init__(self):
        self.state = "menu"
        self.player = None
        self.enemies = []
        self.score = 0
        self.enemy_spawn_timer = 0
        self.enemy_spawn_delay = 60
        self.game_over_timer = 0
        
    def start_game(self):
        self.state = "playing"
        self.player = Player(SCREEN_WIDTH//2, SCREEN_HEIGHT - 100)
        self.enemies = []
        self.score = 0
        self.enemy_spawn_timer = 0
        self.game_over_timer = 0
        
    def update(self):
        if self.state == "playing":
            keys = pygame.key.get_pressed()
            self.player.update(keys)
            
            # 生成敌人
            self.enemy_spawn_timer += 1
            if self.enemy_spawn_timer >= self.enemy_spawn_delay:
                x = random.randint(0, SCREEN_WIDTH - 40)
                self.enemies.append(Enemy(x, -40))
                self.enemy_spawn_timer = 0
                
            # 更新敌人
            for enemy in self.enemies[:]:
                enemy.update()
                
                # 检查敌人是否超出屏幕
                if enemy.y > SCREEN_HEIGHT:
                    self.enemies.remove(enemy)
                    
                # 检查玩家子弹和敌人碰撞
                for bullet in self.player.bullets[:]:
                    if bullet.get_rect().colliderect(enemy.get_rect()):
                        enemy.health -= 1
                        if bullet in self.player.bullets:
                            self.player.bullets.remove(bullet)
                            
                        if enemy.health <= 0:
                            self.score += 100
                            self.enemies.remove(enemy)
                        break
                        
                # 检查敌人子弹和玩家碰撞
                for bullet in enemy.bullets[:]:
                    if bullet.get_rect().colliderect(self.player.get_rect()):
                        self.player.health -= 10
                        if bullet in enemy.bullets:
                            enemy.bullets.remove(bullet)
                            
                        if self.player.health <= 0:
                            self.state = "game_over"
                        break
                        
                # 检查敌人和玩家碰撞
                if self.player.get_rect().colliderect(enemy.get_rect()):
                    self.player.health -= 20
                    self.enemies.remove(enemy)
                    
                    if self.player.health <= 0:
                        self.state = "game_over"
                        
        elif self.state == "game_over":
            self.game_over_timer += 1
            if self.game_over_timer > 180:  # 3秒后返回菜单
                self.state = "menu"
                
    def draw_menu(self, surface):
        surface.fill(BACKGROUND_COLOR)
        
        # 绘制星星
        for _ in range(100):
            x = random.randint(0, SCREEN_WIDTH)
            y = random.randint(0, SCREEN_HEIGHT)
            size = random.randint(1, 3)
            pygame.draw.circle(surface, STAR_COLOR, (x, y), size)
            
        # 标题
        title = font_huge.render("星空射手", True, NEON_BLUE)
        surface.blit(title, (SCREEN_WIDTH//2 - title.get_width()//2, 150))
        
        # 开始提示
        start_text = font_medium.render("按任意键开始游戏", True, NEON_GREEN)
        surface.blit(start_text, (SCREEN_WIDTH//2 - start_text.get_width()//2, 300))
        
        # 控制说明
        controls = [
            "控制方式:",
            "W A S D 或方向键: 移动",
            "空格键: 射击",
            "ESC: 退出游戏"
        ]
        
        for i, control in enumerate(controls):
            control_text = font_small.render(control, True, TEXT_WHITE)
            surface.blit(control_text, (50, 400 + i * 30))
            
    def draw_game(self, surface):
        surface.fill(BACKGROUND_COLOR)
        
        # 绘制星星
        for _ in range(50):
            x = random.randint(0, SCREEN_WIDTH)
            y = random.randint(0, SCREEN_HEIGHT)
            size = random.randint(1, 2)
            pygame.draw.circle(surface, STAR_COLOR, (x, y), size)
            
        # 绘制玩家
        self.player.draw(surface)
        
        # 绘制敌人
        for enemy in self.enemies:
            enemy.draw(surface)
            
        # 绘制UI
        self.draw_ui(surface)
        
    def draw_ui(self, surface):
        # 分数
        score_text = font_large.render(f"分数: {self.score}", True, TEXT_WHITE)
        surface.blit(score_text, (20, 20))
        
        # 血量
        health_text = font_medium.render(f"血量: {self.player.health}", True, TEXT_WHITE)
        surface.blit(health_text, (20, 70))
        
        # 血量条
        health_width = 200
        health_height = 20
        health_ratio = self.player.health / 100
        
        # 血条背景
        pygame.draw.rect(surface, (100, 0, 0), (20, 100, health_width, health_height))
        
        # 当前血量
        if health_ratio > 0:
            current_width = int(health_width * health_ratio)
            pygame.draw.rect(surface, (0, 255, 0), (20, 100, current_width, health_height))
            
    def draw_game_over(self, surface):
        self.draw_game(surface)
        
        # 半透明覆盖
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
        overlay.set_alpha(150)
        overlay.fill((0, 0, 0))
        surface.blit(overlay, (0, 0))
        
        # 游戏结束文本
        game_over_text = font_huge.render("游戏结束", True, NEON_RED)
        surface.blit(game_over_text, (SCREEN_WIDTH//2 - game_over_text.get_width()//2, 200))
        
        score_text = font_large.render(f"最终分数: {self.score}", True, NEON_YELLOW)
        surface.blit(score_text, (SCREEN_WIDTH//2 - score_text.get_width()//2, 300))
        
        restart_text = font_medium.render("3秒后返回菜单...", True, TEXT_WHITE)
        surface.blit(restart_text, (SCREEN_WIDTH//2 - restart_text.get_width()//2, 400))
        
    def draw(self, surface):
        if self.state == "menu":
            self.draw_menu(surface)
        elif self.state == "playing":
            self.draw_game(surface)
        elif self.state == "game_over":
            self.draw_game_over(surface)
            
    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    pygame.quit()
                    sys.exit()
                    
                if self.state == "menu":
                    self.start_game()

def main():
    game = ShootingGame()
    
    while True:
        game.handle_events()
        game.update()
        game.draw(screen)
        pygame.display.flip()
        clock.tick(FPS)

if __name__ == "__main__":
    main()