import pygame
import random
import math
import sys

# ============================================================
# 初始化
# ============================================================
pygame.init()
pygame.mixer.quit()  # 避免音频驱动问题

WIDTH, HEIGHT = 1000, 700
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("🏎️ 2D Racing Game")
clock = pygame.time.Clock()

# 颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GRAY = (100, 100, 100)
DARK_GRAY = (50, 50, 50)
GREEN = (34, 139, 34)
DARK_GREEN = (20, 100, 20)
RED = (220, 30, 30)
BLUE = (30, 80, 220)
YELLOW = (255, 215, 0)
ORANGE = (255, 140, 0)
PURPLE = (150, 30, 200)
CYAN = (0, 200, 255)
SKY_BLUE = (135, 206, 235)

# 字体
font_small = pygame.font.Font(None, 24)
font_med = pygame.font.Font(None, 36)
font_large = pygame.font.Font(None, 72)
font_huge = pygame.font.Font(None, 120)


# ============================================================
# 赛道生成
# ============================================================
class Track:
    def __init__(self):
        self.center_x = WIDTH // 2
        self.center_y = HEIGHT // 2
        self.inner_rx = 280
        self.inner_ry = 180
        self.outer_rx = 440
        self.outer_ry = 300
        self.start_line_angle = -math.pi / 2  # 顶部

        # 预计算赛道中心线路径点
        self.centerline = []
        self.num_points = 200
        for i in range(self.num_points):
            angle = 2 * math.pi * i / self.num_points
            x, y = self._track_point(angle)
            self.centerline.append((x, y))

        # 检查点角度（用于圈数判定）
        self.checkpoints = []
        for i in range(10):
            self.checkpoints.append(2 * math.pi * i / 10)

    def _track_point(self, angle):
        """椭圆赛道中心点"""
        # 加入轻微不规则让赛道更自然
        rx = self.inner_rx + (self.outer_rx - self.inner_rx) * 0.5
        ry = self.inner_ry + (self.outer_ry - self.inner_ry) * 0.5
        # 微调形状
        rx += math.sin(angle * 3) * 15
        ry += math.cos(angle * 2) * 10
        x = self.center_x + rx * math.cos(angle)
        y = self.center_y + ry * math.sin(angle)
        return x, y

    def get_center_point(self, progress):
        """progress: 0~1 表示赛道进度"""
        idx = int(progress * self.num_points) % self.num_points
        return self.centerline[idx]

    def get_angle_at(self, progress):
        """获取赛道在该点的切线方向"""
        idx = int(progress * self.num_points) % self.num_points
        p1 = self.centerline[idx]
        p2 = self.centerline[(idx + 1) % self.num_points]
        return math.atan2(p2[1] - p1[1], p2[0] - p1[0])

    def point_on_track(self, x, y):
        """判断点是否在赛道上，返回 (on_track, distance_from_center, progress)"""
        # 找到最近的中心线点
        min_dist = float('inf')
        best_idx = 0
        # 采样搜索
        for i in range(0, self.num_points, 2):
            cx, cy = self.centerline[i]
            d = math.hypot(x - cx, y - cy)
            if d < min_dist:
                min_dist = d
                best_idx = i

        # 精确搜索附近
        for i in range(max(0, best_idx - 4), min(self.num_points, best_idx + 4)):
            cx, cy = self.centerline[i]
            d = math.hypot(x - cx, y - cy)
            if d < min_dist:
                min_dist = d
                best_idx = i

        cx, cy = self.centerline[best_idx]
        progress = best_idx / self.num_points

        # 赛道宽度（近似椭圆距离）
        track_half_width = (self.outer_rx - self.inner_rx) * 0.5 - 10
        on_track = min_dist <= track_half_width
        on_grass_near = min_dist <= track_half_width + 40

        return on_track, min_dist, progress, on_grass_near

    def draw(self, screen):
        # 草地背景
        screen.fill(DARK_GREEN)

        # 外赛道（深灰）
        outer_points = []
        for i in range(self.num_points):
            angle = 2 * math.pi * i / self.num_points
            rx = self.outer_rx + math.sin(angle * 3) * 15
            ry = self.outer_ry + math.cos(angle * 2) * 10
            x = self.center_x + rx * math.cos(angle)
            y = self.center_y + ry * math.sin(angle)
            outer_points.append((x, y))
        pygame.draw.polygon(screen, DARK_GRAY, outer_points)

        # 内赛道（赛道表面）
        inner_points = []
        for i in range(self.num_points):
            angle = 2 * math.pi * i / self.num_points
            rx = self.inner_rx + math.sin(angle * 3) * 15
            ry = self.inner_ry + math.cos(angle * 2) * 10
            x = self.center_x + rx * math.cos(angle)
            y = self.center_y + ry * math.sin(angle)
            inner_points.append((x, y))
        pygame.draw.polygon(screen, GRAY, inner_points)

        # 起跑线
        start_idx = int(self.num_points * 0.75)  # 顶部偏左
        p1 = inner_points[start_idx]
        p2 = outer_points[start_idx]
        # 画格子旗图案
        steps = 10
        for i in range(steps):
            t1 = i / steps
            t2 = (i + 1) / steps
            a1 = WHITE if (i % 2 == 0) else BLACK
            a2 = BLACK if (i % 2 == 0) else WHITE
            pygame.draw.line(screen, a1,
                             (p1[0] + (p2[0] - p1[0]) * t1, p1[1] + (p2[1] - p1[1]) * t1),
                             (p1[0] + (p2[0] - p1[0]) * t2, p1[1] + (p2[1] - p1[1]) * t2), 4)

        # 路边白线
        pygame.draw.lines(screen, WHITE, True, inner_points, 2)
        pygame.draw.lines(screen, WHITE, True, outer_points, 2)


# ============================================================
# 赛车类
# ============================================================
CAR_COLORS = [
    {"name": "Red Bull", "color": RED, "accel": 0.35, "max_speed": 7.5, "handling": 0.045, "toughness": 0.92},
    {"name": "Mercedes", "color": CYAN, "accel": 0.30, "max_speed": 8.0, "handling": 0.040, "toughness": 0.88},
    {"name": "Ferrari", "color": ORANGE, "accel": 0.38, "max_speed": 7.2, "handling": 0.042, "toughness": 0.85},
    {"name": "McLaren", "color": ORANGE, "color2": DARK_GRAY, "accel": 0.33, "max_speed": 7.6, "handling": 0.043, "toughness": 0.90},
]

class Car:
    def __init__(self, car_type, x, y, angle, is_player=False):
        self.car_type = car_type
        self.x = x
        self.y = y
        self.angle = angle
        self.speed = 0
        self.is_player = is_player

        info = CAR_COLORS[car_type]
        self.color = info["color"]
        self.accel = info["accel"]
        self.max_speed = info["max_speed"]
        self.handling = info["handling"]
        self.toughness = info["toughness"]

        # 状态
        self.stun_timer = 0
        self.turbo_energy = 100.0
        self.turbo_active = False
        self.lap = 0
        self.progress = 0.0
        self.last_progress = 0.0
        self.checkpoint = 0
        self.finished = False
        self.finish_time = 0.0
        self.lap_times = []
        self.current_lap_time = 0.0
        self.best_lap = None

        # 粒子
        self.particles = []

    def update(self, keys, track, dt, all_cars=None):
        if self.finished:
            return

        self.current_lap_time += dt

        # 涡轮
        if self.turbo_active and self.turbo_energy > 0:
            self.turbo_energy -= 30 * dt  # 每秒消耗30%
            if self.turbo_energy <= 0:
                self.turbo_active = False
                self.turbo_energy = 0
        else:
            self.turbo_energy = min(100.0, self.turbo_energy + 8 * dt)

        # 输入
        accel_input = 0
        turn_input = 0

        if self.is_player:
            if self.stun_timer > 0:
                self.stun_timer -= dt
            else:
                if keys[pygame.K_w] or keys[pygame.K_UP]:
                    accel_input = 1
                if keys[pygame.K_s] or keys[pygame.K_DOWN]:
                    accel_input = -0.6
                if keys[pygame.K_a] or keys[pygame.K_LEFT]:
                    turn_input = -1
                if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
                    turn_input = 1
                if keys[pygame.K_SPACE] or keys[pygame.K_LSHIFT]:
                    if self.turbo_energy > 10:
                        self.turbo_active = True
                else:
                    self.turbo_active = False
        else:
            # AI 逻辑
            if self.stun_timer > 0:
                self.stun_timer -= dt
                accel_input = 0
            else:
                target_progress = (self.progress + 0.02) % 1.0
                tx, ty = track.get_center_point(target_progress)
                desired_angle = math.atan2(ty - self.y, tx - self.x)
                angle_diff = desired_angle - self.angle
                while angle_diff > math.pi:
                    angle_diff -= 2 * math.pi
                while angle_diff < -math.pi:
                    angle_diff += 2 * math.pi

                turn_input = max(-1, min(1, angle_diff * 3))
                accel_input = 0.8
                # AI也用涡轮
                if self.turbo_energy > 50 and abs(angle_diff) < 0.2:
                    self.turbo_active = True
                else:
                    self.turbo_active = False

        # 物理
        current_max_speed = self.max_speed
        current_accel = self.accel
        if self.turbo_active:
            current_max_speed *= 1.45
            current_accel *= 1.3

        # 加速
        if accel_input > 0:
            self.speed += current_accel * accel_input
        elif accel_input < 0:
            self.speed += current_accel * accel_input * 0.7
        else:
            self.speed *= 0.98  # 摩擦

        self.speed = max(-2.0, min(current_max_speed, self.speed))

        # 转向（速度越快转向越大，但有上限）
        if abs(self.speed) > 0.5:
            turn_factor = min(abs(self.speed) / 3.0, 1.0)
            self.angle += turn_input * self.handling * turn_factor * (1 if self.speed > 0 else -1)

        # 移动
        new_x = self.x + self.speed * math.cos(self.angle)
        new_y = self.y + self.speed * math.sin(self.angle)

        # 碰撞检测
        on_track, dist, progress, on_grass_near = track.point_on_track(new_x, new_y)

        if on_track:
            self.x = new_x
            self.y = new_y
            # 草地边缘轻微减速
            if not on_track and on_grass_near:
                self.speed *= 0.95
        else:
            # 撞墙
            self.speed *= -0.3 * self.toughness
            self.stun_timer = 0.3 * (2 - self.toughness)
            self.x -= math.cos(self.angle) * 5
            self.y -= math.sin(self.angle) * 5

        # 草地减速
        on_track_now, _, _, _ = track.point_on_track(self.x, self.y)
        if not on_track_now:
            self.speed *= 0.92

        # 更新进度
        _, _, self.progress, _ = track.point_on_track(self.x, self.y)

        # 圈数检测
        if self.last_progress > 0.9 and self.progress < 0.1:
            self.lap += 1
            if len(self.lap_times) < 3:
                self.lap_times.append(self.current_lap_time)
                if self.best_lap is None or self.current_lap_time < self.best_lap:
                    self.best_lap = self.current_lap_time
            self.current_lap_time = 0.0
            if self.lap >= 3:
                self.finished = True
        elif self.last_progress < 0.1 and self.progress > 0.9:
            self.lap -= 1

        self.last_progress = self.progress

        # 车与车碰撞
        if all_cars:
            for other in all_cars:
                if other is self:
                    continue
                d = math.hypot(self.x - other.x, self.y - other.y)
                if d < 25:
                    push_x = (self.x - other.x) / d * 5
                    push_y = (self.y - other.y) / d * 5
                    self.x += push_x
                    self.y += push_y
                    other.x -= push_x
                    other.y -= push_y
                    self.speed *= 0.8
                    other.speed *= 0.8

        # 涡轮粒子
        if self.turbo_active and abs(self.speed) > 1:
            for _ in range(3):
                px = self.x - math.cos(self.angle) * 15 + random.uniform(-5, 5)
                py = self.y - math.sin(self.angle) * 15 + random.uniform(-5, 5)
                self.particles.append({
                    'x': px, 'y': py,
                    'vx': -math.cos(self.angle) * random.uniform(2, 5) + random.uniform(-1, 1),
                    'vy': -math.sin(self.angle) * random.uniform(2, 5) + random.uniform(-1, 1),
                    'life': 1.0,
                    'color': random.choice([ORANGE, YELLOW, RED, (255, 255, 200)])
                })

        # 更新粒子
        for p in self.particles[:]:
            p['x'] += p['vx']
            p['y'] += p['vy']
            p['life'] -= dt * 3
            if p['life'] <= 0:
                self.particles.remove(p)

    def draw(self, screen):
        # 画粒子
        for p in self.particles:
            alpha = int(p['life'] * 255)
            size = int(p['life'] * 6)
            if size > 0:
                surf = pygame.Surface((size * 2, size * 2), pygame.SRCALPHA)
                pygame.draw.circle(surf, (*p['color'], alpha), (size, size), size)
                screen.blit(surf, (p['x'] - size, p['y'] - size))

        # 车身
        car_surface = pygame.Surface((32, 18), pygame.SRCALPHA)

        # 车身主体
        pygame.draw.ellipse(car_surface, self.color, (2, 2, 28, 14))

        # 驾驶舱
        cockpit_color = BLACK if not hasattr(CAR_COLORS[self.car_type], '__iter__') else (20, 20, 30)
        pygame.draw.rect(car_surface, cockpit_color, (12, 4, 10, 10), border_radius=3)

        # 车轮
        wheel_color = (30, 30, 30)
        pygame.draw.rect(car_surface, wheel_color, (4, 0, 6, 3))
        pygame.draw.rect(car_surface, wheel_color, (22, 0, 6, 3))
        pygame.draw.rect(car_surface, wheel_color, (4, 15, 6, 3))
        pygame.draw.rect(car_surface, wheel_color, (22, 15, 6, 3))

        # 前灯
        pygame.draw.circle(car_surface, YELLOW, (28, 5), 2)
        pygame.draw.circle(car_surface, YELLOW, (28, 13), 2)

        # 旋转
        rotated = pygame.transform.rotate(car_surface, -math.degrees(self.angle))
        rect = rotated.get_rect(center=(self.x, self.y))

        # 眩晕效果
        if self.stun_timer > 0:
            pygame.draw.circle(screen, YELLOW, (int(self.x), int(self.y - 20)), int(self.stun_timer * 10))

        screen.blit(rotated, rect)

        # 玩家标记
        if self.is_player:
            pygame.draw.circle(screen, YELLOW, (int(self.x), int(self.y)), 20, 2)


# ============================================================
# 粒子系统（背景星星等）
# ============================================================
class StarField:
    def __init__(self):
        self.stars = []
        for _ in range(100):
            self.stars.append([
                random.randint(0, WIDTH),
                random.randint(0, HEIGHT),
                random.uniform(0.5, 2.0),
                random.uniform(0.02, 0.08)
            ])

    def update(self):
        for star in self.stars:
            star[1] += star[3] * 60
            if star[1] > HEIGHT:
                star[1] = 0
                star[0] = random.randint(0, WIDTH)

    def draw(self, surface):
        for star in self.stars:
            pygame.draw.circle(surface, WHITE, (int(star[0]), int(star[1])), int(star[2]))


# ============================================================
# 主菜单
# ============================================================
def draw_main_menu(selected_car):
    overlay = pygame.Surface((WIDTH, HEIGHT))
    overlay.fill((10, 10, 30))
    screen.blit(overlay, (0, 0))

    # 标题
    title = font_huge.render("2D RACING", True, YELLOW)
    screen.blit(title, (WIDTH // 2 - title.get_width() // 2, 80))

    subtitle = font_med.render("Select Your Car & Press ENTER to Race!", True, WHITE)
    screen.blit(subtitle, (WIDTH // 2 - subtitle.get_width() // 2, 160))

    # 赛车选择
    car_spacing = 220
    start_x = WIDTH // 2 - (len(CAR_COLORS) * car_spacing) // 2 + car_spacing // 2

    for i, car_info in enumerate(CAR_COLORS):
        cx = start_x + i * car_spacing
        cy = 350

        # 选中框
        if i == selected_car:
            pygame.draw.rect(screen, YELLOW, (cx - 80, cy - 70, 160, 200), 3, border_radius=10)
            pygame.draw.rect(screen, (255, 255, 0, 50), (cx - 78, cy - 68, 156, 196), border_radius=10)

        # 赛车预览
        preview = pygame.Surface((60, 30), pygame.SRCALPHA)
        pygame.draw.ellipse(preview, car_info["color"], (0, 5, 55, 20))
        pygame.draw.rect(preview, BLACK, (22, 8, 16, 14), border_radius=3)
        screen.blit(pygame.transform.rotate(preview, -90), (cx - 30, cy - 50))

        # 名字
        name_text = font_small.render(car_info["name"], True, WHITE)
        screen.blit(name_text, (cx - name_text.get_width() // 2, cy + 10))

        # 属性条
        attrs = [
            ("SPD", car_info["max_speed"] / 8.0),
            ("ACC", car_info["accel"] / 0.38),
            ("HND", car_info["handling"] / 0.045),
        ]
        for j, (label, val) in enumerate(attrs):
            label_surf = font_small.render(label, True, GRAY)
            screen.blit(label_surf, (cx - 60, cy + 35 + j * 18))
            bar_w = 80
            pygame.draw.rect(screen, DARK_GRAY, (cx - 20, cy + 35 + j * 18, bar_w, 14))
            pygame.draw.rect(screen, GREEN, (cx - 20, cy + 35 + j * 18, int(bar_w * val), 14))

    # 操作说明
    controls = [
        "WASD / Arrows - Drive",
        "SPACE / LSHIFT - Turbo Boost",
        "ESC - Pause",
    ]
    for i, c in enumerate(controls):
        t = font_small.render(c, True, (180, 180, 180))
        screen.blit(t, (WIDTH // 2 - t.get_width() // 2, 530 + i * 25))

    hint = font_small.render("<- -> to select | ENTER to start", True, YELLOW)
    screen.blit(hint, (WIDTH // 2 - hint.get_width() // 2, 620))


# ============================================================
# HUD
# ============================================================
def draw_hud(screen, player, cars, race_time, state):
    # 左上：速度
    speed_kmh = int(abs(player.speed) * 40)
    speed_text = font_large.render(f"{speed_kmh}", True, WHITE)
    screen.blit(speed_text, (20, 20))
    screen.blit(font_small.render("km/h", True, GRAY), (25, 80))

    # 右上：圈数和时间
    lap_text = font_med.render(f"Lap: {min(player.lap + 1, 3)}/3", True, WHITE)
    screen.blit(lap_text, (WIDTH - lap_text.get_width() - 20, 20))

    time_text = font_med.render(f"Time: {race_time:.1f}s", True, WHITE)
    screen.blit(time_text, (WIDTH - time_text.get_width() - 20, 55))

    if player.best_lap:
        best_text = font_small.render(f"Best: {player.best_lap:.1f}s", True, YELLOW)
        screen.blit(best_text, (WIDTH - best_text.get_width() - 20, 90))

    # 排名
    sorted_cars = sorted(cars, key=lambda c: (c.lap, c.progress), reverse=True)
    rank = sorted_cars.index(player) + 1
    rank_text = font_med.render(f"Rank: P{rank}/{len(cars)}", True, WHITE)
    screen.blit(rank_text, (WIDTH - rank_text.get_width() - 20, 115))

    # 涡轮能量条
    bar_w, bar_h = 200, 20
    bar_x, bar_y = WIDTH // 2 - bar_w // 2, 20
    pygame.draw.rect(screen, DARK_GRAY, (bar_x, bar_y, bar_w, bar_h), border_radius=10)
    energy_ratio = player.turbo_energy / 100.0
    energy_color = RED if energy_ratio < 0.3 else (ORANGE if energy_ratio < 0.6 else CYAN)
    pygame.draw.rect(screen, energy_color, (bar_x, bar_y, int(bar_w * energy_ratio), bar_h), border_radius=10)
    turbo_label = font_small.render("TURBO", True, WHITE)
    screen.blit(turbo_label, (bar_x + bar_w // 2 - turbo_label.get_width() // 2, bar_y + 2))

    # 检查点进度条
    prog_bar_w = 300
    prog_bar_x = WIDTH // 2 - prog_bar_w // 2
    prog_bar_y = 50
    pygame.draw.rect(screen, DARK_GRAY, (prog_bar_x, prog_bar_y, prog_bar_w, 8), border_radius=4)
    pygame.draw.rect(screen, YELLOW, (prog_bar_x, prog_bar_y, int(prog_bar_w * player.progress), 8), border_radius=4)

    # 迷你排名列表
    mini_y = 145
    screen.blit(font_small.render("Standings:", True, GRAY), (WIDTH - 130, mini_y))
    for i, c in enumerate(sorted_cars[:4]):
        color = YELLOW if c.is_player else WHITE
        txt = font_small.render(f"{i+1}. {'YOU' if c.is_player else c.car_type}", True, color)
        screen.blit(txt, (WIDTH - 130, mini_y + 20 + i * 18))


# ============================================================
# 倒计时
# ============================================================
def draw_countdown(countdown_val):
    if countdown_val > 0:
        num = math.ceil(countdown_val)
        text = font_huge.render(str(num), True, YELLOW if num > 1 else RED)
        screen.blit(text, (WIDTH // 2 - text.get_width() // 2, HEIGHT // 2 - text.get_height() // 2))
    else:
        text = font_huge.render("GO!", True, GREEN)
        alpha = int(min(255, countdown_val + 1) * 255)
        text.set_alpha(alpha)
        screen.blit(text, (WIDTH // 2 - text.get_width() // 2, HEIGHT // 2 - text.get_height() // 2))


# ============================================================
# 暂停界面
# ============================================================
def draw_pause():
    overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
    overlay.fill((0, 0, 0, 150))
    screen.blit(overlay, (0, 0))
    text = font_huge.render("PAUSED", True, WHITE)
    screen.blit(text, (WIDTH // 2 - text.get_width() // 2, HEIGHT // 2 - 50))
    hint = font_med.render("Press ESC to Resume", True, GRAY)
    screen.blit(hint, (WIDTH // 2 - hint.get_width() // 2, HEIGHT // 2 + 30))


# ============================================================
# 结算界面
# ============================================================
def draw_results(cars, race_time):
    overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
    overlay.fill((0, 0, 0, 200))
    screen.blit(overlay, (0, 0))

    title = font_huge.render("RACE RESULTS", True, YELLOW)
    screen.blit(title, (WIDTH // 2 - title.get_width() // 2, 80))

    sorted_cars = sorted(cars, key=lambda c: (c.finished, c.lap, c.progress), reverse=True)

    for i, car in enumerate(sorted_cars):
        y_pos = 200 + i * 70
        medal = ["🥇", "🥈", "🥉"][i] if i < 3 else f"{i+1}."
        color = YELLOW if car.is_player else WHITE

        name = f"{medal} {'YOU' if car.is_player else CAR_COLORS[car.car_type]['name']}"
        text = font_large.render(name, True, color)
        screen.blit(text, (WIDTH // 2 - 250, y_pos))

        # 成绩
        if car.finished and car.lap_times:
            total = sum(car.lap_times)
            result = f"Total: {total:.1f}s | Best Lap: {car.best_lap:.1f}s"
        elif car.lap_times:
            total = sum(car.lap_times) + car.current_lap_time
            result = f"Progress: Lap {min(car.lap+1, 3)}/{3} | Time: {total:.1f}s"
        else:
            result = "DNF"

        res_text = font_med.render(result, True, GRAY)
        screen.blit(res_text, (WIDTH // 2 - 250, y_pos + 40))

    hint = font_med.render("Press R to Race Again | M for Menu", True, WHITE)
    screen.blit(hint, (WIDTH // 2 - hint.get_width() // 2, HEIGHT - 80))


# ============================================================
# 游戏状态
# ============================================================
STATE_MENU = 0
STATE_COUNTDOWN = 1
STATE_RACING = 2
STATE_PAUSED = 3
STATE_RESULTS = 4

# ============================================================
# 主循环
# ============================================================
def main():
    stars = StarField()
    track = Track()
    state = STATE_MENU
    selected_car = 0
    cars = []
    countdown_val = 3.0
    race_start_time = 0.0
    pause_overlay = None

    while True:
        dt = clock.tick(60) / 1000.0
        dt = min(dt, 0.05)  # 防止大帧跳跃

        keys = pygame.key.get_pressed()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

            if event.type == pygame.KEYDOWN:
                if state == STATE_MENU:
                    if event.key == pygame.K_LEFT:
                        selected_car = (selected_car - 1) % len(CAR_COLORS)
                    elif event.key == pygame.K_RIGHT:
                        selected_car = (selected_car + 1) % len(CAR_COLORS)
                    elif event.key == pygame.K_RETURN:
                        # 创建赛车
                        cars = []
                        # 玩家
                        start_angle = track.start_line_angle
                        sx, sy = track.get_center_point(0.75)
                        player = Car(selected_car, sx, sy, start_angle, is_player=True)
                        cars.append(player)

                        # AI
                        ai_types = [i for i in range(len(CAR_COLORS)) if i != selected_car]
                        random.shuffle(ai_types)
                        for i, ai_type in enumerate(ai_types[:3]):
                            offset = (i + 1) * 0.015
                            ax, ay = track.get_center_point(0.75 - offset)
                            ai = Car(ai_type, ax, ay, start_angle)
                            # AI难度差异
                            ai.max_speed *= (0.85 + i * 0.05)
                            ai.accel *= (0.9 + i * 0.03)
                            cars.append(ai)

                        state = STATE_COUNTDOWN
                        countdown_val = 3.0

                elif state == STATE_RACING:
                    if event.key == pygame.K_ESCAPE:
                        state = STATE_PAUSED

                elif state == STATE_PAUSED:
                    if event.key == pygame.K_ESCAPE:
                        state = STATE_RACING

                elif state == STATE_RESULTS:
                    if event.key == pygame.K_r:
                        # 重新开始
                        cars = []
                        sx, sy = track.get_center_point(0.75)
                        player = Car(selected_car, sx, sy, track.start_line_angle, is_player=True)
                        cars.append(player)
                        ai_types = [i for i in range(len(CAR_COLORS)) if i != selected_car]
                        random.shuffle(ai_types)
                        for i, ai_type in enumerate(ai_types[:3]):
                            offset = (i + 1) * 0.015
                            ax, ay = track.get_center_point(0.75 - offset)
                            ai = Car(ai_type, ax, ay, track.start_line_angle)
                            ai.max_speed *= (0.85 + i * 0.05)
                            ai.accel *= (0.9 + i * 0.03)
                            cars.append(ai)
                        state = STATE_COUNTDOWN
                        countdown_val = 3.0
                    elif event.key == pygame.K_m:
                        state = STATE_MENU

        # 更新逻辑
        if state == STATE_MENU:
            stars.update()

        elif state == STATE_COUNTDOWN:
            countdown_val -= dt
            if countdown_val <= -1.0:
                state = STATE_RACING
                race_start_time = pygame.time.get_ticks() / 1000.0

        elif state == STATE_RACING:
            for car in cars:
                car.update(keys, track, dt, cars)

            # 检查是否全部完成
            if all(c.finished for c in cars):
                state = STATE_RESULTS

        elif state == STATE_PAUSED:
            pass

        # 绘制
        if state == STATE_MENU:
            stars.draw(screen)
            draw_main_menu(selected_car)

        else:
            track.draw(screen)

            # 按Y排序绘制（伪3D深度）
            for car in sorted(cars, key=lambda c: c.y):
                car.draw(screen)

            if state == STATE_RACING or state == STATE_PAUSED or state == STATE_RESULTS:
                race_time = pygame.time.get_ticks() / 1000.0 - race_start_time
                draw_hud(screen, cars[0], cars, race_time, state)

            if state == STATE_COUNTDOWN:
                race_time = 0.0
                draw_hud(screen, cars[0], cars, race_time, state)
                draw_countdown(countdown_val)

            if state == STATE_PAUSED:
                draw_pause()

            if state == STATE_RESULTS:
                race_time = pygame.time.get_ticks() / 1000.0 - race_start_time
                draw_results(cars, race_time)

        pygame.display.flip()


if __name__ == "__main__":
    main()