import pygame
import random
import sys

# 初始化pygame
pygame.init()

# 游戏常量定义
WIDTH, HEIGHT = 800, 600
FPS = 60
CAR_WIDTH, CAR_HEIGHT = 50, 80
ROAD_WIDTH = 400
OBSTACLE_WIDTH, OBSTACLE_HEIGHT = 50, 80

# 更真实的颜色定义
SKY_BLUE = (135, 206, 235)          # 天空蓝
ASPHALT = (40, 40, 40)              # 沥青色（道路）
GREENERY = (34, 139, 34)            # 绿化带颜色
WHITE = (255, 255, 255)             # 白色（道路边缘）
YELLOW = (255, 204, 0)              # 亮黄色（道路中心线）
DARK_YELLOW = (204, 153, 0)         # 深黄色（中心线阴影）
CAR_BLUE = (0, 102, 204)            # 赛车蓝色
CAR_WHITE = (240, 248, 255)         # 赛车车窗白
BLACK = (0, 0, 0)                   # 黑色（车轮）
RED = (204, 0, 0)                   # 暗红色（障碍物）

# 创建游戏窗口
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("2D 赛车驾驶小游戏 - 真实背景版")
clock = pygame.time.Clock()

# 字体设置
font = pygame.font.Font(None, 40)


class Car:
    """赛车类"""

    def __init__(self):
        self.x = WIDTH // 2 - CAR_WIDTH // 2
        self.y = HEIGHT - CAR_HEIGHT - 20
        self.speed = 8
        self.rect = pygame.Rect(self.x, self.y, CAR_WIDTH, CAR_HEIGHT)

    def draw(self):
        """绘制赛车"""
        # 绘制车身（蓝色主体）
        pygame.draw.rect(screen, CAR_BLUE, self.rect)
        # 绘制车身高光
        pygame.draw.rect(screen, CAR_WHITE, (self.x + 5,
                         self.y + 5, CAR_WIDTH - 10, CAR_HEIGHT // 4), 1)
        # 绘制车窗（浅白色）
        pygame.draw.rect(screen, CAR_WHITE, (self.x + 10,
                         self.y + 10, CAR_WIDTH - 20, CAR_HEIGHT // 3))
        # 绘制车轮（黑色）
        wheel_radius = 10
        # 前轮
        pygame.draw.circle(screen, BLACK, (self.x + 10,
                           self.y + CAR_HEIGHT - wheel_radius), wheel_radius)
        pygame.draw.circle(screen, WHITE, (self.x + 10, self.y +
                           CAR_HEIGHT - wheel_radius), wheel_radius - 3)
        # 右前轮
        pygame.draw.circle(screen, BLACK, (self.x + CAR_WIDTH -
                           10, self.y + CAR_HEIGHT - wheel_radius), wheel_radius)
        pygame.draw.circle(screen, WHITE, (self.x + CAR_WIDTH - 10,
                           self.y + CAR_HEIGHT - wheel_radius), wheel_radius - 3)
        # 后轮
        pygame.draw.circle(screen, BLACK, (self.x + 10,
                           self.y + wheel_radius), wheel_radius)
        pygame.draw.circle(screen, WHITE, (self.x + 10,
                           self.y + wheel_radius), wheel_radius - 3)
        # 右后轮
        pygame.draw.circle(
            screen, BLACK, (self.x + CAR_WIDTH - 10, self.y + wheel_radius), wheel_radius)
        pygame.draw.circle(screen, WHITE, (self.x + CAR_WIDTH -
                           10, self.y + wheel_radius), wheel_radius - 3)

    def move(self, dx, dy):
        """移动赛车，限制在道路范围内"""
        new_x = self.x + dx * self.speed
        new_y = self.y + dy * self.speed

        # 道路边界限制（左右）
        road_left = (WIDTH - ROAD_WIDTH) // 2
        road_right = road_left + ROAD_WIDTH

        if road_left <= new_x <= road_right - CAR_WIDTH:
            self.x = new_x
        if 0 <= new_y <= HEIGHT - CAR_HEIGHT:
            self.y = new_y

        # 更新碰撞矩形
        self.rect.x = self.x
        self.rect.y = self.y


class Obstacle:
    """障碍物类"""

    def __init__(self):
        road_left = (WIDTH - ROAD_WIDTH) // 2
        road_right = road_left + ROAD_WIDTH
        self.x = random.randint(road_left, road_right - OBSTACLE_WIDTH)
        self.y = -OBSTACLE_HEIGHT
        self.speed = 5
        self.rect = pygame.Rect(
            self.x, self.y, OBSTACLE_WIDTH, OBSTACLE_HEIGHT)

    def update(self):
        """更新障碍物位置"""
        self.y += self.speed
        self.rect.y = self.y
        return self.y < HEIGHT  # 返回是否还在屏幕内

    def draw(self):
        """绘制更真实的障碍物"""
        # 主障碍物
        pygame.draw.rect(screen, RED, self.rect)
        # 阴影效果
        pygame.draw.rect(screen, (100, 0, 0), (self.x + 3,
                         self.y + 3, OBSTACLE_WIDTH - 6, OBSTACLE_HEIGHT - 6))
        # 白色反光条
        pygame.draw.rect(screen, WHITE, (self.x + 5,
                         self.y + 20, OBSTACLE_WIDTH - 10, 5))
        pygame.draw.rect(screen, WHITE, (self.x + 5,
                         self.y + 50, OBSTACLE_WIDTH - 10, 5))


def draw_realistic_road():
    """绘制更真实的道路背景"""
    # 1. 绘制天空背景
    screen.fill(SKY_BLUE)

    # 2. 绘制两侧绿化带
    road_left = (WIDTH - ROAD_WIDTH) // 2
    road_right = road_left + ROAD_WIDTH
    # 左侧绿化带
    pygame.draw.rect(screen, GREENERY, (0, 0, road_left - 20, HEIGHT))
    # 右侧绿化带
    pygame.draw.rect(screen, GREENERY, (road_right + 20,
                     0, WIDTH - road_right - 20, HEIGHT))

    # 3. 绘制路肩（浅灰色）
    pygame.draw.rect(screen, (169, 169, 169), (road_left - 10, 0, 10, HEIGHT))
    pygame.draw.rect(screen, (169, 169, 169), (road_right, 0, 10, HEIGHT))

    # 4. 绘制沥青道路
    pygame.draw.rect(screen, ASPHALT, (road_left, 0, ROAD_WIDTH, HEIGHT))

    # 5. 添加道路纹理（模拟路面颗粒感）
    for i in range(0, HEIGHT, 20):
        for j in range(road_left + 20, road_right - 20, 30):
            pygame.draw.circle(screen, (45, 45, 45), (j, i), 1)

    # 6. 绘制更真实的道路中心线（双黄线）
    center_y = 0
    while center_y < HEIGHT:
        # 主黄线
        pygame.draw.rect(screen, YELLOW, (WIDTH // 2 - 3, center_y, 6, 40))
        # 阴影效果增强立体感
        pygame.draw.rect(screen, DARK_YELLOW,
                         (WIDTH // 2 - 3, center_y + 2, 6, 36))
        center_y += 80

    # 7. 绘制道路边缘白线
    pygame.draw.rect(screen, WHITE, (road_left + 5, 0, 3, HEIGHT))
    pygame.draw.rect(screen, WHITE, (road_right - 8, 0, 3, HEIGHT))

    # 8. 添加远处道路渐变效果（模拟透视）
    fade_surface = pygame.Surface((ROAD_WIDTH, HEIGHT), pygame.SRCALPHA)
    fade_surface.fill((0, 0, 0, 30))
    screen.blit(fade_surface, (road_left, 0))


def main_game():
    """主游戏函数"""
    car = Car()
    obstacles = []
    score = 0
    game_over = False

    # 障碍物生成计时器
    obstacle_timer = 0
    obstacle_spawn_rate = 60  # 每60帧生成一个障碍物

    running = True
    while running:
        # 控制游戏帧率
        clock.tick(FPS)

        # 事件处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            # 游戏结束后按空格键重置
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE and game_over:
                    main_game()  # 重新开始游戏

        if not game_over:
            # 键盘控制
            keys = pygame.key.get_pressed()
            dx, dy = 0, 0
            if keys[pygame.K_LEFT] or keys[pygame.K_a]:
                dx = -1
            if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
                dx = 1
            if keys[pygame.K_UP] or keys[pygame.K_w]:
                dy = -1
            if keys[pygame.K_DOWN] or keys[pygame.K_s]:
                dy = 1
            car.move(dx, dy)

            # 生成障碍物
            obstacle_timer += 1
            if obstacle_timer >= obstacle_spawn_rate:
                obstacles.append(Obstacle())
                obstacle_timer = 0
                # 随机调整生成速率，增加游戏难度
                obstacle_spawn_rate = random.randint(40, 80)

            # 更新障碍物
            new_obstacles = []
            for obstacle in obstacles:
                if obstacle.update():
                    new_obstacles.append(obstacle)
                    # 碰撞检测
                    if car.rect.colliderect(obstacle.rect):
                        game_over = True
                else:
                    # 障碍物移出屏幕，加分
                    score += 10
            obstacles = new_obstacles

        # 绘制游戏画面（先画背景，再画前景）
        draw_realistic_road()         # 绘制真实感道路
        car.draw()                    # 绘制赛车

        # 绘制障碍物
        for obstacle in obstacles:
            obstacle.draw()

        # 绘制分数（带半透明背景）
        score_bg = pygame.Rect(10, 10, 150, 50)
        pygame.draw.rect(screen, (0, 0, 0, 128), score_bg)
        score_text = font.render(f"分数: {score}", True, WHITE)
        screen.blit(score_text, (20, 20))

        # 游戏结束提示（更美观）
        if game_over:
            # 半透明遮罩
            overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
            overlay.fill((0, 0, 0, 150))
            screen.blit(overlay, (0, 0))

            # 游戏结束文字
            game_over_text = font.render("游戏结束！", True, RED)
            restart_text = font.render("按空格键重新开始", True, WHITE)

            text1_rect = game_over_text.get_rect(
                center=(WIDTH//2, HEIGHT//2 - 30))
            text2_rect = restart_text.get_rect(
                center=(WIDTH//2, HEIGHT//2 + 10))

            screen.blit(game_over_text, text1_rect)
            screen.blit(restart_text, text2_rect)

        # 更新显示
        pygame.display.flip()

    # 退出游戏
    pygame.quit()
    sys.exit()


# 启动游戏
if __name__ == "__main__":
    main_game()
