"""
===========================================
  是男人就上一百层
  修复：简介页面元组解包错误
===========================================
"""

import pygame
import random
import math
import sys
import json
import os

# ============================================================
# 初始化
# ============================================================

pygame.init()

SCREEN_WIDTH = 700
SCREEN_HEIGHT = 900
FPS = 60

# 颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 50, 50)
GREEN = (50, 200, 50)
BLUE = (50, 150, 250)
YELLOW = (255, 220, 50)
PURPLE = (180, 50, 230)
ORANGE = (255, 160, 20)
CYAN = (0, 210, 240)
PINK = (255, 120, 190)
GRAY = (128, 128, 128)
DARK_GRAY = (64, 64, 64)
LIGHT_GRAY = (192, 192, 192)
BROWN = (139, 69, 19)
GOLD = (215, 185, 15)
SKY_BLUE = (135, 206, 235)

# ============================================================
# 字体加载
# ============================================================

def get_font(size):
    """获取中文字体"""
    paths = [
        "C:/Windows/Fonts/simhei.ttf",
        "C:/Windows/Fonts/msyh.ttc",
        "C:/Windows/Fonts/simsun.ttc",
    ]
    for path in paths:
        if os.path.exists(path):
            try:
                return pygame.font.Font(path, size)
            except:
                continue
    return pygame.font.Font(None, size)

# ============================================================
# 粒子系统
# ============================================================

class Particle:
    def __init__(self, x, y, color, vx, vy, life=30):
        self.x = x
        self.y = y
        self.color = color
        self.vx = vx
        self.vy = vy
        self.life = life
        self.age = 0
        self.size = random.randint(2, 5)
        
    def update(self):
        self.x += self.vx
        self.y += self.vy
        self.vy += 0.2
        self.age += 1
        return self.age < self.life
        
    def draw(self, screen):
        size = max(1, int(self.size * (1 - self.age / self.life)))
        pygame.draw.circle(screen, self.color, (int(self.x), int(self.y)), size)

class ParticleSystem:
    def __init__(self):
        self.particles = []
        
    def burst(self, x, y, color, count=15):
        for _ in range(count):
            angle = random.uniform(0, 2 * math.pi)
            speed = random.uniform(1, 4)
            self.particles.append(Particle(x, y, color,
                                         math.cos(angle)*speed,
                                         math.sin(angle)*speed - 2))
            
    def update(self):
        self.particles = [p for p in self.particles if p.update()]
        
    def draw(self, screen):
        for p in self.particles:
            p.draw(screen)

# ============================================================
# 平台类
# ============================================================

class Platform:
    TYPES = {
        'normal': GREEN,
        'moving': BLUE,
        'fragile': BROWN,
        'spring': YELLOW,
        'vanish': PURPLE,
        'lava': RED,
        'ice': CYAN
    }
    
    def __init__(self, x, y, w=70, h=12):
        self.rect = pygame.Rect(x, y, w, h)
        self.type = 'normal'
        self.bounced = False
        self.orig_x = x
        self.dir = 1
        self.hits = 0
        self.max_hits = 3
        self.vanish_timer = 90
        self.has_coin = random.random() < 0.25
        self.got_coin = False
        
    def update(self):
        if self.type == 'moving':
            self.rect.x += 2 * self.dir
            if abs(self.rect.x - self.orig_x) > 80:
                self.dir *= -1
                
        elif self.type == 'vanish' and self.bounced:
            self.vanish_timer -= 1
            if self.vanish_timer <= 0:
                return False
                
        elif self.type == 'fragile' and self.bounced:
            self.hits += 1
            if self.hits >= self.max_hits:
                return False
                
        return True
        
    def get_color(self):
        base = self.TYPES.get(self.type, GREEN)
        if self.type == 'fragile':
            ratio = self.hits / self.max_hits
            return (min(255, int(base[0] + (255-base[0])*ratio)),
                   int(base[1]*(1-ratio*0.5)),
                   int(base[2]*(1-ratio*0.5)))
        return base
        
    def draw(self, screen):
        color = self.get_color()
        pygame.draw.rect(screen, color, self.rect)
        pygame.draw.rect(screen, DARK_GRAY, self.rect, 2)
        
        # 特殊装饰
        if self.type == 'spring':
            pygame.draw.ellipse(screen, ORANGE,
                              (self.rect.centerx-8, self.rect.top-6, 16, 6))
        elif self.type == 'lava':
            for i in range(3):
                pygame.draw.circle(screen, ORANGE,
                                 (self.rect.left+10+i*20, self.rect.top-random.randint(2,6)), 3)
        elif self.type == 'ice':
            for i in range(3):
                pygame.draw.circle(screen, WHITE,
                                 (self.rect.left+15+i*22, self.rect.centery), 2)
        
        # 金币
        if self.has_coin and not self.got_coin:
            pygame.draw.circle(screen, GOLD, (self.rect.centerx, self.rect.top-12), 7)
            pygame.draw.circle(screen, YELLOW, (self.rect.centerx, self.rect.top-12), 5)

# ============================================================
# 玩家类
# ============================================================

class Player:
    def __init__(self, x, y):
        self.width = 28
        self.height = 36
        self.rect = pygame.Rect(x, y, self.width, self.height)
        self.vy = 0
        self.vx = 0
        self.jumps = 2
        self.max_jumps = 2
        self.score = 0
        self.coins = 0
        self.combo = 0
        self.shield = False
        self.shield_timer = 0
        self.speed_boost = False
        self.speed_timer = 0
        self.anim_frame = 0
        self.anim_counter = 0
        
    def jump(self):
        if self.jumps > 0:
            self.vy = -12
            self.jumps -= 1
            return True
        return False
        
    def move(self, dx):
        speed = 9 if self.speed_boost else 6
        self.vx = dx * speed
        
    def update(self):
        self.vy += 0.5
        if self.vy > 15:
            self.vy = 15
        self.rect.x += self.vx
        self.rect.y += self.vy
        self.vx *= 0.85
        
        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.right > SCREEN_WIDTH:
            self.rect.right = SCREEN_WIDTH
            
        if self.shield:
            self.shield_timer -= 1
            if self.shield_timer <= 0:
                self.shield = False
                
        if self.speed_boost:
            self.speed_timer -= 1
            if self.speed_timer <= 0:
                self.speed_boost = False
                
        self.anim_counter += 1
        if self.anim_counter > 5:
            self.anim_frame = (self.anim_frame + 1) % 4
            self.anim_counter = 0
            
    def draw(self, screen):
        if self.shield and self.shield_timer % 6 < 3:
            return
            
        body_color = YELLOW if self.speed_boost else RED
        
        # 头
        pygame.draw.ellipse(screen, PINK, (self.rect.centerx-10, self.rect.top, 20, 14))
        # 眼睛
        pygame.draw.circle(screen, BLACK, (self.rect.centerx-4, self.rect.top+5), 2)
        pygame.draw.circle(screen, BLACK, (self.rect.centerx+4, self.rect.top+5), 2)
        # 身体
        pygame.draw.rect(screen, body_color,
                        (self.rect.left+2, self.rect.top+12, self.width-4, self.height-17))
        # 手臂动画
        swing = math.sin(self.anim_frame * math.pi / 2) * 3
        pygame.draw.rect(screen, PINK, (self.rect.left-3, self.rect.top+14+swing, 5, 10))
        pygame.draw.rect(screen, PINK, (self.rect.right-2, self.rect.top+14-swing, 5, 10))
        # 腿
        leg = math.sin(self.anim_frame * math.pi / 2) * 2
        pygame.draw.rect(screen, BLUE, (self.rect.left+3, self.rect.bottom-8+leg, 8, 8))
        pygame.draw.rect(screen, BLUE, (self.rect.right-11, self.rect.bottom-8-leg, 8, 8))
        # 护盾光环
        if self.shield:
            pygame.draw.circle(screen, BLUE, self.rect.center, 22, 2)

# ============================================================
# 游戏主类
# ============================================================

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.running = True
        self.state = "intro"
        
        self.player = None
        self.platforms = []
        self.enemies = []
        self.powerups = []
        self.particles = ParticleSystem()
        
        self.font_large = get_font(48)
        self.font_medium = get_font(32)
        self.font_small = get_font(20)
        self.font_combo = get_font(40)
        self.font_intro = get_font(18)
        
        self.high_score = 0
        self.total_coins = 0
        self.difficulty = 1
        self.timer = 0
        self.shake = 0
        self.combo_timer = 0
        self.intro_scroll = 0
        
        self.load_data()
        
    def load_data(self):
        try:
            with open('data.json') as f:
                data = json.load(f)
                self.high_score = data.get('score', 0)
                self.total_coins = data.get('coins', 0)
        except:
            pass
            
    def save_data(self):
        try:
            with open('data.json', 'w') as f:
                json.dump({'score': self.high_score, 'coins': self.total_coins}, f)
        except:
            pass
            
    def start_game(self):
        self.state = "playing"
        self.player = Player(SCREEN_WIDTH//2, SCREEN_HEIGHT-100)
        self.platforms = []
        self.enemies = []
        self.powerups = []
        self.particles = ParticleSystem()
        self.difficulty = 1
        self.timer = 0
        self.shake = 0
        self.combo_timer = 0
        
        # 初始平台
        self.platforms.append(Platform(SCREEN_WIDTH//2-75, SCREEN_HEIGHT-30, 150, 14))
        
        # 生成10个平台
        for _ in range(10):
            self.add_platform()
            
    def add_platform(self):
        last = self.platforms[-1]
        gap = 65 - min(self.difficulty * 2, 25) + random.randint(-10, 10)
        x = random.randint(0, SCREEN_WIDTH-70)
        y = last.rect.top - gap
        
        # 选择平台类型
        r = random.random()
        if r < 0.5 or self.difficulty < 2:
            ptype = 'normal'
        elif r < 0.59:
            ptype = 'moving'
        elif r < 0.68:
            ptype = 'fragile'
        elif r < 0.77:
            ptype = 'spring'
        elif r < 0.85:
            ptype = 'vanish'
        elif r < 0.93:
            ptype = 'lava'
        else:
            ptype = 'ice'
            
        p = Platform(x, y)
        p.type = ptype
        self.platforms.append(p)
        
        # 添加敌人
        if random.random() < 0.028 + self.difficulty * 0.003:
            ex = random.randint(0, SCREEN_WIDTH-30)
            ey = y - 40
            self.enemies.append({
                'rect': pygame.Rect(ex, ey, 26, 30),
                'type': random.choice(['bird', 'spike']),
                'speed': random.uniform(1, 3),
                'dir': random.choice([-1, 1])
            })
            
        # 添加道具
        if random.random() < 0.014:
            px = random.randint(0, SCREEN_WIDTH-20)
            py = y - 30
            self.powerups.append({
                'rect': pygame.Rect(px, py, 18, 18),
                'type': random.choice(['double_jump', 'speed', 'shield'])
            })
            
    def handle_input(self):
        keys = pygame.key.get_pressed()
        dx = 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_SPACE] or keys[pygame.K_UP] or keys[pygame.K_w]:
            if self.player.jump():
                self.particles.burst(self.player.rect.centerx, self.player.rect.bottom, WHITE, 8)
                
        self.player.move(dx)
        
    def check_collisions(self):
        player = self.player
        
        # 平台碰撞
        for p in self.platforms[:]:
            if player.vy > 0 and player.rect.colliderect(p.rect):
                if player.rect.bottom <= p.rect.centery + 10:
                    
                    if p.type == 'lava':
                        self.game_over()
                        return
                        
                    elif p.type == 'spring':
                        player.vy = -18
                        self.particles.burst(p.rect.centerx, p.rect.top, YELLOW, 15)
                        self.shake = 5
                    else:
                        player.vy = -12
                        
                    player.rect.bottom = p.rect.top
                    player.jumps = player.max_jumps
                    p.bounced = True
                    
                    # 金币
                    if p.has_coin and not p.got_coin:
                        p.got_coin = True
                        player.coins += 1
                        self.particles.burst(p.rect.centerx, p.rect.top-12, GOLD, 10)
                        
                    # 连击
                    player.combo += 1
                    self.combo_timer = 45
                    if player.combo > 1:
                        player.score += player.combo * 2
                        
        # 道具碰撞
        for pu in self.powerups[:]:
            if player.rect.colliderect(pu['rect']):
                if pu['type'] == 'double_jump':
                    player.max_jumps = 3
                    player.jumps = 3
                elif pu['type'] == 'speed':
                    player.speed_boost = True
                    player.speed_timer = 300
                elif pu['type'] == 'shield':
                    player.shield = True
                    player.shield_timer = 500
                    
                self.powerups.remove(pu)
                self.particles.burst(pu['rect'].centerx, pu['rect'].centery, PURPLE, 12)
                
        # 敌人碰撞
        for e in self.enemies[:]:
            if player.rect.colliderect(e['rect']):
                if player.shield:
                    self.enemies.remove(e)
                    self.particles.burst(e['rect'].centerx, e['rect'].centery, RED, 10)
                else:
                    self.game_over()
                    return
                    
    def scroll_screen(self):
        player = self.player
        
        if player.rect.top < SCREEN_HEIGHT // 3:
            offset = SCREEN_HEIGHT // 3 - player.rect.top
            player.rect.y += offset
            
            for p in self.platforms[:]:
                p.rect.y += offset
                if p.rect.top > SCREEN_HEIGHT:
                    self.platforms.remove(p)
                    self.add_platform()
                    
            for e in self.enemies[:]:
                e['rect'].y += offset
                if e['rect'].top > SCREEN_HEIGHT:
                    self.enemies.remove(e)
                    
            for pu in self.powerups[:]:
                pu['rect'].y += offset
                if pu['rect'].top > SCREEN_HEIGHT:
                    self.powerups.remove(pu)
                    
            player.score += 1
            self.timer += 1
            if self.timer % 580 == 0:
                self.difficulty += 1
                
    def game_over(self):
        self.state = "gameover"
        if self.player.score > self.high_score:
            self.high_score = self.player.score
        self.total_coins += self.player.coins
        self.save_data()
        self.shake = 15
        
    def update(self):
        if self.state == "intro":
            self.intro_scroll += 1
            if self.intro_scroll > 660:
                self.state = "menu"
                
        elif self.state == "playing":
            self.timer += 1
            self.handle_input()
            self.player.update()
            self.check_collisions()
            self.scroll_screen()
            
            self.platforms = [p for p in self.platforms if p.update()]
            
            for e in self.enemies:
                e['rect'].x += e['speed'] * e['dir']
                if e['rect'].left < 0 or e['rect'].right > SCREEN_WIDTH:
                    e['dir'] *= -1
                    
            self.particles.update()
            
            if self.combo_timer > 0:
                self.combo_timer -= 1
            else:
                self.player.combo = 0
                
            if self.shake > 0:
                self.shake -= 1
                
            if self.player.rect.top > SCREEN_HEIGHT:
                self.game_over()
                
    def draw_background(self):
        for i in range(SCREEN_HEIGHT):
            cv = int(125 + (195-125) * i / SCREEN_HEIGHT)
            pygame.draw.line(self.screen, (cv, 212, 226), (0, i), (SCREEN_WIDTH, i))
            
    def draw_intro(self):
        """绘制游戏简介页面"""
        self.draw_background()
        
        # 半透明覆盖层
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
        overlay.set_alpha(60)
        overlay.fill(BLACK)
        self.screen.blit(overlay, (0, 0))
        

        
        # 分隔线
        pygame.draw.line(self.screen, GOLD, (80, 145), (SCREEN_WIDTH-80, 145), 2)
        
        # 简介内容 - 使用列表存储，每项都是完整的两元素元组
        intro_items = [
            ("🎯 游戏目标", "不断向上跳跃，挑战最高层数！"),
            ("🎮 基本操作", "← → 移动 | 空格/↑ 跳跃 | ESC 暂停"),
            ("", ""),
            ("🌟 平台类型", "共7种不同特性的平台"),
            ("  绿 普通平台", "最基本的落脚点"),
            ("  蓝 移动平台", "会左右来回移动"),
            ("  棕 易碎平台", "踩几次就会碎裂"),
            ("  黄 弹簧平台", "弹得更高更远"),
            ("  紫 消失平台", "踩过后会消失"),
            ("  红 岩浆平台", "碰到立即死亡"),
            ("  青 冰面平台", "表面光滑容易滑倒"),
            ("", ""),
            ("💎 道具系统", "收集道具获得特殊能力"),
            ("   绿色光球", "获得三段跳能力"),
            ("   黄色光球", "获得加速效果"),
            ("   蓝色光球", "获得护盾保护"),
            ("", ""),
            ("🏆 评分系统", "连击越高，得分加成越多"),
            ("💡 小技巧", "善用二段跳和弹簧平台"),
        ]
        
        y_offset = 100
        for title_text, desc_text in intro_items:
            if title_text.startswith(("🎯", "🎮", "🌟", "💎", "🏆", "💡")):
                # 大类标题
                render = self.font_medium.render(title_text, True, GOLD)
                self.screen.blit(render, (35, y_offset))
                y_offset += 30
                if desc_text:
                    render = self.font_intro.render(desc_text, True, WHITE)
                    self.screen.blit(render, (55, y_offset))
                    y_offset += 24
            elif title_text.startswith("  "):
                # 子项内容
                render = self.font_intro.render(title_text, True, LIGHT_GRAY)
                self.screen.blit(render, (55, y_offset))
                if desc_text:
                    render = self.font_intro.render(desc_text, True, WHITE)
                    self.screen.blit(render, (190, y_offset))
                y_offset += 22
            else:
                # 空行
                y_offset += 8
                
        # 底部闪烁提示
        if self.intro_scroll % 40 < 20:
            tip = self.font_small.render("按 空格键 进入游戏", True, GOLD)
            tip_rect = tip.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT-70))
            self.screen.blit(tip, tip_rect)
            
        # 版本信息
        version = self.font_intro.render("v3.0 豪华版 | 按ESC跳过简介", True, GRAY)
        version_rect = version.get_rect(center=(SCREEN_WIDTH//2, SCREEN_HEIGHT-30))
        self.screen.blit(version, version_rect)
            
    def draw_menu(self):
        self.draw_background()
        title = self.font_large.render("是男人就上一百层", True, BLACK)
        rect = title.get_rect(center=(SCREEN_WIDTH//2, 220))
        self.screen.blit(title, rect)
        
        hs = self.font_medium.render(f"最高分: {self.high_score}", True, GOLD)
        rect = hs.get_rect(center=(SCREEN_WIDTH//2, 288))
        self.screen.blit(hs, rect)
        
        coins = self.font_small.render(f"总金币: {self.total_coins}", True, GOLD)
        rect = coins.get_rect(center=(SCREEN_WIDTH//2, 328))
        self.screen.blit(coins, rect)
        
        tip = self.font_small.render("按空格键开始游戏", True, GRAY)
        rect = tip.get_rect(center=(SCREEN_WIDTH//2, 388))
        self.screen.blit(tip, rect)
        
    def draw(self):
        self.screen.fill(SKY_BLUE)
        
        if self.state == "intro":
            self.draw_intro()
            
        elif self.state == "menu":
            self.draw_menu()
            
        elif self.state == "playing":
            self.draw_background()
            
            # 屏幕震动
            ox, oy = 0, 0
            if self.shake > 0:
                ox = random.randint(-self.shake, self.shake)
                oy = random.randint(-self.shake, self.shake)
                
            temp = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
            temp.fill(SKY_BLUE)
            
            for p in self.platforms:
                p.draw(temp)
                
            for e in self.enemies:
                if e['type'] == 'bird':
                    pygame.draw.ellipse(temp, BROWN, e['rect'])
                else:
                    pts = [(e['rect'].centerx, e['rect'].top),
                          (e['rect'].left, e['rect'].bottom),
                          (e['rect'].right, e['rect'].bottom)]
                    pygame.draw.polygon(temp, RED, pts)
                    
            for pu in self.powerups:
                colors = {'double_jump': GREEN, 'speed': YELLOW, 'shield': BLUE}
                color = colors.get(pu['type'], WHITE)
                pygame.draw.circle(temp, color, pu['rect'].center, 9)
                pygame.draw.circle(temp, WHITE, pu['rect'].center, 5)
                
            self.player.draw(temp)
            self.particles.draw(temp)
            
            self.screen.blit(temp, (ox, oy))
            
            # UI
            score = self.font_medium.render(f"分数: {self.player.score}", True, BLACK)
            self.screen.blit(score, (10, 10))
            
            coins = self.font_small.render(f"金币: {self.player.coins}", True, GOLD)
            self.screen.blit(coins, (10, 45))
            
            if self.combo_timer > 0 and self.player.combo > 1:
                combo = self.font_combo.render(f"{self.player.combo}x 连击!", True, ORANGE)
                rect = combo.get_rect(center=(SCREEN_WIDTH//2, 100))
                self.screen.blit(combo, rect)
                
            # 暂停提示
            pause = self.font_small.render("ESC暂停", True, DARK_GRAY)
            self.screen.blit(pause, (SCREEN_WIDTH-90, 10))
            
        elif self.state == "gameover":
            self.draw_background()
            
            overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
            overlay.set_alpha(180)
            overlay.fill(BLACK)
            self.screen.blit(overlay, (0, 0))
            
            go = self.font_large.render("游戏结束", True, RED)
            rect = go.get_rect(center=(SCREEN_WIDTH//2, 232))
            self.screen.blit(go, rect)
            
            score = self.font_medium.render(f"得分: {self.player.score}", True, WHITE)
            rect = score.get_rect(center=(SCREEN_WIDTH//2, 302))
            self.screen.blit(score, rect)
            
            coins = self.font_medium.render(f"金币: {self.player.coins}", True, GOLD)
            rect = coins.get_rect(center=(SCREEN_WIDTH//2, 348))
            self.screen.blit(coins, rect)
            
            hs = self.font_small.render(f"最高分: {self.high_score}", True, YELLOW)
            rect = hs.get_rect(center=(SCREEN_WIDTH//2, 396))
            self.screen.blit(hs, rect)
            
            tip = self.font_small.render("按空格键重新开始", True, LIGHT_GRAY)
            rect = tip.get_rect(center=(SCREEN_WIDTH//2, 462))
            self.screen.blit(tip, rect)
            
        pygame.display.flip()
        
    def run(self):
        while self.running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                    
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_SPACE:
                        if self.state == "intro":
                            self.state = "menu"
                        elif self.state == "menu":
                            self.start_game()
                        elif self.state == "gameover":
                            self.start_game()
                    elif event.key == pygame.K_ESCAPE:
                        if self.state == "playing":
                            self.state = "menu"
                        elif self.state == "intro":
                            self.state = "menu"
                            
            self.update()
            self.draw()
            self.clock.tick(FPS)
            
        pygame.quit()
        sys.exit()

# ============================================================
# 运行游戏
# ============================================================

if __name__ == "__main__":
    print("=" * 50)
    print("  是男人就上一百层")
    print("=" * 50)
    print("操作说明:")
    print("  ← → / A D : 左右移动")
    print("  空格 / ↑ / W : 跳跃")
    print("  ESC : 暂停/返回菜单")
    print("=" * 50)
    
    game = Game()
    game.run()