import pygame
import random
import sys
import time
import math
from enum import Enum

# ========== 初始化 ==========
pygame.init()
WINDOW_WIDTH = 1000
WINDOW_HEIGHT = 750
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("🏝️ 荒岛求生 · 生存挑战")
clock = pygame.time.Clock()
FPS = 60

# ========== 中文字体 ==========
def get_font(size, bold=False):
    font_names = [
        "SimHei", "Microsoft YaHei", "STHeiti", 
        "Noto Sans CJK SC", "WenQuanYi Micro Hei"
    ]
    for name in font_names:
        try:
            font = pygame.font.SysFont(name, size, bold=bold)
            test = font.render("测试", True, (255, 255, 255))
            if test.get_width() > 0:
                return font
        except:
            continue
    
    try:
        font_paths = [
            "C:/Windows/Fonts/simsun.ttc",
            "/System/Library/Fonts/PingFang.ttc",
        ]
        for path in font_paths:
            if __import__('os').path.exists(path):
                return pygame.font.Font(path, size)
    except:
        pass
    
    return pygame.font.Font(None, size)

# ========== 颜色定义（完整版） ==========
COLORS = {
    "sky": (135, 206, 235),
    "ocean": (30, 144, 255),
    "ocean_deep": (20, 100, 200),
    "sand": (238, 214, 175),
    "sand_dark": (210, 180, 140),
    "grass": (34, 139, 34),
    "grass_light": (50, 180, 50),
    "tree_trunk": (139, 69, 19),
    "tree_top": (0, 100, 0),
    "palm_trunk": (160, 82, 45),
    "palm_top": (50, 150, 50),
    "rock": (128, 128, 128),
    "water": (100, 180, 255),
    "fire": (255, 100, 0),
    "player": (255, 200, 100),
    "ui_bg": (0, 0, 0, 180),
    "white": (255, 255, 255),
    "black": (0, 0, 0),
    "gray": (128, 128, 128),
    "light_gray": (200, 200, 200),
    "red": (255, 50, 50),
    "green": (50, 255, 50),
    "blue": (50, 150, 255),           # ← 添加 blue
    "gold": (255, 215, 0),
    "orange": (255, 165, 0),
    "brown": (139, 69, 19),
    "dark_green": (0, 80, 0),
    "yellow": (255, 255, 0),
    "purple": (200, 50, 255),
    "pink": (255, 100, 150),
    "cyan": (0, 255, 255),
    "dark_red": (139, 0, 0),
    "dark_blue": (0, 0, 139),
    "dark_gray": (64, 64, 64),
    "transparent_black": (0, 0, 0, 180),
}

# ========== 资源类型 ==========
class ResourceType(Enum):
    WOOD = "木材"
    STONE = "石头"
    FOOD = "食物"
    WATER = "水"
    FIBER = "纤维"
    LEAF = "树叶"
    BAMBOO = "竹子"

# ========== 资源节点 ==========
class ResourceNode:
    def __init__(self, x, y, resource_type, amount=10):
        self.x = x
        self.y = y
        self.resource_type = resource_type
        self.max_amount = amount
        self.amount = amount
        self.radius = 15
        self.respawn_time = 0
        self.is_alive = True
    
    def gather(self, amount=1):
        if not self.is_alive:
            return 0
        gathered = min(amount, self.amount)
        self.amount -= gathered
        if self.amount <= 0:
            self.is_alive = False
            self.respawn_time = 300
        return gathered
    
    def update(self):
        if not self.is_alive:
            self.respawn_time -= 1
            if self.respawn_time <= 0:
                self.amount = self.max_amount
                self.is_alive = True
    
    def draw(self, screen, camera_x, camera_y):
        if not self.is_alive:
            return
        
        screen_x = self.x - camera_x
        screen_y = self.y - camera_y
        
        colors = {
            ResourceType.WOOD: (139, 69, 19),
            ResourceType.STONE: (128, 128, 128),
            ResourceType.FOOD: (50, 200, 50),
            ResourceType.WATER: (100, 180, 255),
            ResourceType.FIBER: (200, 200, 150),
            ResourceType.LEAF: (50, 200, 100),
            ResourceType.BAMBOO: (100, 200, 100),
        }
        color = colors.get(self.resource_type, (200, 200, 200))
        
        pygame.draw.circle(screen, color, (int(screen_x), int(screen_y)), self.radius)
        pygame.draw.circle(screen, (0, 0, 0), (int(screen_x), int(screen_y)), self.radius, 2)
        
        if self.amount > 0:
            font = get_font(12)
            text = font.render(str(self.amount), True, COLORS["white"])
            text_rect = text.get_rect(center=(screen_x, screen_y))
            screen.blit(text, text_rect)

# ========== 玩家 ==========
class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 24
        self.height = 32
        self.speed = 2.5
        self.vx = 0
        self.vy = 0
        
        self.health = 100
        self.max_health = 100
        self.hunger = 100
        self.thirst = 100
        self.energy = 100
        
        self.inventory = {}
        self.max_inventory = 20
        
        self.tools = {
            "stone_axe": False,
            "stone_pickaxe": False,
            "fishing_rod": False,
            "campfire": False,
            "shelter": False,
        }
        
        self.is_moving = False
        self.facing = "down"
        self.animation_frame = 0
        self.action_timer = 0
        self.gathering = False
        self.gather_timer = 0
        
        self.survival_time = 0
        self.day = 1
    
    def update(self, resources, world_width, world_height):
        self.x += self.vx
        self.y += self.vy
        
        self.x = max(0, min(self.x, world_width - self.width))
        self.y = max(0, min(self.y, world_height - self.height))
        
        if random.random() < 0.002:
            self.hunger = max(0, self.hunger - 1)
        if random.random() < 0.003:
            self.thirst = max(0, self.thirst - 1)
        if random.random() < 0.001:
            self.energy = max(0, self.energy - 1)
        
        if self.hunger <= 0:
            if random.random() < 0.01:
                self.health = max(0, self.health - 2)
        if self.thirst <= 0:
            if random.random() < 0.015:
                self.health = max(0, self.health - 3)
        
        if self.gathering:
            self.gather_timer += 1
            if self.gather_timer >= 30:
                self.gather_timer = 0
                self.try_gather(resources)
        
        self.survival_time += 1 / FPS
        if self.survival_time >= 86400:
            self.survival_time = 0
            self.day += 1
    
    def try_gather(self, resources):
        for resource in resources:
            dx = self.x + self.width/2 - resource.x
            dy = self.y + self.height/2 - resource.y
            dist = math.sqrt(dx*dx + dy*dy)
            
            if dist < 60 and resource.is_alive:
                gathered = resource.gather(1)
                if gathered > 0:
                    self.add_item(resource.resource_type.value, 1)
                    return True
        return False
    
    def add_item(self, item_name, count=1):
        if len(self.inventory) < self.max_inventory:
            self.inventory[item_name] = self.inventory.get(item_name, 0) + count
            return True
        return False
    
    def remove_item(self, item_name, count=1):
        if self.inventory.get(item_name, 0) >= count:
            self.inventory[item_name] -= count
            if self.inventory[item_name] <= 0:
                del self.inventory[item_name]
            return True
        return False
    
    def eat(self):
        for item in ["食物", "水果", "鱼"]:
            if self.remove_item(item, 1):
                self.hunger = min(100, self.hunger + 30)
                self.health = min(100, self.health + 10)
                return True
        return False
    
    def drink(self):
        if self.remove_item("水", 1):
            self.thirst = min(100, self.thirst + 40)
            return True
        return False
    
    def take_damage(self, damage):
        self.health = max(0, self.health - damage)
        return self.health <= 0
    
    def heal(self, amount):
        self.health = min(self.max_health, self.health + amount)
    
    def draw(self, screen, camera_x, camera_y):
        screen_x = self.x - camera_x
        screen_y = self.y - camera_y
        
        body_rect = (screen_x, screen_y - 10, self.width, self.height)
        pygame.draw.rect(screen, COLORS["player"], body_rect)
        
        head_center = (screen_x + self.width//2, screen_y - 5)
        pygame.draw.circle(screen, (255, 220, 150), head_center, 12)
        
        eye_offset = {
            "up": (0, -3),
            "down": (0, 3),
            "left": (-3, 0),
            "right": (3, 0)
        }
        offset = eye_offset.get(self.facing, (0, 0))
        eye_y = screen_y - 5 + offset[1]
        
        pygame.draw.circle(screen, COLORS["white"], 
                          (int(screen_x + 8 + offset[0]), int(eye_y)), 4)
        pygame.draw.circle(screen, COLORS["white"], 
                          (int(screen_x + 16 + offset[0]), int(eye_y)), 4)
        pygame.draw.circle(screen, COLORS["black"], 
                          (int(screen_x + 9 + offset[0]), int(eye_y)), 2)
        pygame.draw.circle(screen, COLORS["black"], 
                          (int(screen_x + 17 + offset[0]), int(eye_y)), 2)
        
        font = get_font(14)
        name_text = font.render("🏝️ 幸存者", True, COLORS["white"])
        name_rect = name_text.get_rect(center=(screen_x + self.width//2, screen_y - 25))
        screen.blit(name_text, name_rect)

# ========== 岛屿生成器 ==========
class IslandGenerator:
    def __init__(self, width=2000, height=2000):
        self.width = width
        self.height = height
        self.resources = []
        self.obstacles = []
        self.generate_island()
    
    def generate_island(self):
        num_resources = 80
        
        for _ in range(num_resources):
            x = random.randint(100, self.width - 100)
            y = random.randint(100, self.height - 100)
            
            resource_type = random.choice(list(ResourceType))
            amount = random.randint(5, 15)
            
            if resource_type == ResourceType.WATER:
                if x < 200 or x > self.width - 200 or y < 200 or y > self.height - 200:
                    self.resources.append(ResourceNode(x, y, resource_type, amount))
            elif resource_type == ResourceType.STONE:
                if 400 < x < self.width - 400 and 400 < y < self.height - 400:
                    self.resources.append(ResourceNode(x, y, resource_type, amount))
            else:
                self.resources.append(ResourceNode(x, y, resource_type, amount))
        
        self.ensure_resources()
    
    def ensure_resources(self):
        for r_type in ResourceType:
            has_type = any(r.resource_type == r_type for r in self.resources)
            if not has_type:
                x = random.randint(200, self.width - 200)
                y = random.randint(200, self.height - 200)
                self.resources.append(ResourceNode(x, y, r_type, 10))

# ========== 游戏主类 ==========
class SurvivalGame:
    def __init__(self):
        self.font_small = get_font(16)
        self.font_medium = get_font(24)
        self.font_large = get_font(32)
        self.font_huge = get_font(48, bold=True)
        
        self.world_width = 2000
        self.world_height = 2000
        self.island = IslandGenerator(self.world_width, self.world_height)
        
        self.player = Player(self.world_width//2, self.world_height//2)
        
        self.camera_x = 0
        self.camera_y = 0
        
        self.is_running = True
        self.is_paused = False
        self.is_game_over = False
        self.game_over_reason = ""
        
        self.keys = {
            "up": False,
            "down": False,
            "left": False,
            "right": False,
        }
        
        self.messages = []
        self.message_timer = 0
        self.interact_timer = 0
        self.show_help = True
    
    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.is_running = False
            
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    self.is_running = False
                elif event.key == pygame.K_p:
                    self.is_paused = not self.is_paused
                elif event.key == pygame.K_h:
                    self.show_help = not self.show_help
                
                elif event.key == pygame.K_w:
                    self.keys["up"] = True
                elif event.key == pygame.K_s:
                    self.keys["down"] = True
                elif event.key == pygame.K_a:
                    self.keys["left"] = True
                elif event.key == pygame.K_d:
                    self.keys["right"] = True
                
                elif event.key == pygame.K_SPACE:
                    self.player.gathering = True
                elif event.key == pygame.K_e:
                    self.player.eat()
                elif event.key == pygame.K_r:
                    self.player.drink()
                elif event.key == pygame.K_c:
                    self.craft_item()
                elif event.key == pygame.K_r and self.is_game_over:
                    self.restart_game()
            
            elif event.type == pygame.KEYUP:
                if event.key == pygame.K_w:
                    self.keys["up"] = False
                elif event.key == pygame.K_s:
                    self.keys["down"] = False
                elif event.key == pygame.K_a:
                    self.keys["left"] = False
                elif event.key == pygame.K_d:
                    self.keys["right"] = False
                elif event.key == pygame.K_SPACE:
                    self.player.gathering = False
                    self.player.gather_timer = 0
    
    def craft_item(self):
        recipes = {
            "石斧": {"木材": 3, "石头": 2},
            "石镐": {"木材": 3, "石头": 3},
            "篝火": {"木材": 5, "石头": 3},
            "简易屋棚": {"木材": 10, "树叶": 5, "纤维": 3},
            "钓鱼竿": {"木材": 4, "纤维": 2, "竹子": 1},
        }
        
        if self.player.tools["stone_axe"]:
            self.add_message("💡 你已经拥有石斧了！", COLORS["gray"])
            return
        
        if self.player.remove_item("木材", 3) and self.player.remove_item("石头", 2):
            self.player.tools["stone_axe"] = True
            self.add_message("✅ 合成成功：石斧！", COLORS["green"])
        else:
            self.add_message("❌ 材料不足！需要：木材x3, 石头x2", COLORS["red"])
    
    def update(self):
        if self.is_paused or self.is_game_over:
            return
        
        self.player.vx = 0
        self.player.vy = 0
        if self.keys["up"]:
            self.player.vy = -self.player.speed
            self.player.facing = "up"
        if self.keys["down"]:
            self.player.vy = self.player.speed
            self.player.facing = "down"
        if self.keys["left"]:
            self.player.vx = -self.player.speed
            self.player.facing = "left"
        if self.keys["right"]:
            self.player.vx = self.player.speed
            self.player.facing = "right"
        
        self.player.update(self.island.resources, self.world_width, self.world_height)
        
        for resource in self.island.resources:
            resource.update()
        
        self.camera_x = self.player.x - WINDOW_WIDTH//2 + self.player.width//2
        self.camera_y = self.player.y - WINDOW_HEIGHT//2 + self.player.height//2
        self.camera_x = max(0, min(self.camera_x, self.world_width - WINDOW_WIDTH))
        self.camera_y = max(0, min(self.camera_y, self.world_height - WINDOW_HEIGHT))
        
        if self.player.health <= 0:
            self.is_game_over = True
            self.game_over_reason = "💀 你因伤病过重而死亡..."
        elif self.player.hunger <= 0 and self.player.thirst <= 0:
            self.is_game_over = True
            self.game_over_reason = "💀 你因饥饿和干渴而倒下..."
        
        if self.message_timer > 0:
            self.message_timer -= 1
    
    def add_message(self, msg, color=COLORS["white"]):
        self.messages.append((msg, color))
        if len(self.messages) > 5:
            self.messages.pop(0)
        self.message_timer = 120
    
    def render(self):
        screen.fill(COLORS["sky"])
        
        ocean_rect = pygame.Rect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
        pygame.draw.rect(screen, COLORS["ocean"], ocean_rect)
        
        for x in range(-50, self.world_width + 50, 40):
            for y in range(-50, self.world_height + 50, 40):
                screen_x = x - self.camera_x
                screen_y = y - self.camera_y
                if -50 < screen_x < WINDOW_WIDTH + 50 and -50 < screen_y < WINDOW_HEIGHT + 50:
                    color = COLORS["sand"] if (x + y) % 80 < 40 else COLORS["sand_dark"]
                    pygame.draw.rect(screen, color, (screen_x, screen_y, 40, 40))
        
        for x in range(100, self.world_width - 100, 30):
            for y in range(100, self.world_height - 100, 30):
                if random.random() < 0.05:
                    screen_x = x - self.camera_x
                    screen_y = y - self.camera_y
                    if -50 < screen_x < WINDOW_WIDTH + 50 and -50 < screen_y < WINDOW_HEIGHT + 50:
                        color = COLORS["grass"] if random.random() < 0.5 else COLORS["grass_light"]
                        pygame.draw.rect(screen, color, (screen_x, screen_y, 3, 8))
        
        for resource in self.island.resources:
            resource.draw(screen, self.camera_x, self.camera_y)
        
        self.player.draw(screen, self.camera_x, self.camera_y)
        
        self.render_ui()
        
        if self.messages:
            y_offset = 100
            for msg, color in self.messages[-5:]:
                msg_surf = self.font_small.render(msg, True, color)
                msg_rect = msg_surf.get_rect(center=(WINDOW_WIDTH//2, y_offset))
                screen.blit(msg_surf, msg_rect)
                y_offset += 30
        
        if self.is_paused:
            overlay = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT))
            overlay.set_alpha(150)
            overlay.fill((0, 0, 0))
            screen.blit(overlay, (0, 0))
            pause_text = self.font_huge.render("⏸️ 暂停", True, COLORS["white"])
            pause_rect = pause_text.get_rect(center=(WINDOW_WIDTH//2, WINDOW_HEIGHT//2))
            screen.blit(pause_text, pause_rect)
        
        if self.is_game_over:
            self.render_game_over()
        
        if self.show_help and not self.is_game_over:
            self.render_help()
        
        pygame.display.flip()
    
    def render_ui(self):
        ui_bg = pygame.Surface((WINDOW_WIDTH, 80))
        ui_bg.set_alpha(180)
        ui_bg.fill((0, 0, 0))
        screen.blit(ui_bg, (0, 0))
        screen.blit(ui_bg, (0, WINDOW_HEIGHT - 60))
        
        # 生命值
        health_text = self.font_small.render(f"❤️ {self.player.health}", True, COLORS["red"])
        screen.blit(health_text, (10, 10))
        pygame.draw.rect(screen, (60, 0, 0), (80, 12, 100, 15))
        pygame.draw.rect(screen, COLORS["red"], (80, 12, int(100 * self.player.health/self.player.max_health), 15))
        
        # 饥饿值
        hunger_text = self.font_small.render(f"🍖 {self.player.hunger}", True, COLORS["orange"])
        screen.blit(hunger_text, (10, 32))
        pygame.draw.rect(screen, (60, 30, 0), (80, 34, 100, 15))
        pygame.draw.rect(screen, COLORS["orange"], (80, 34, int(100 * self.player.hunger/100), 15))
        
        # 口渴值 - 修复：使用 COLORS["blue"]
        thirst_text = self.font_small.render(f"💧 {self.player.thirst}", True, COLORS["blue"])
        screen.blit(thirst_text, (200, 10))
        pygame.draw.rect(screen, (0, 0, 60), (270, 12, 100, 15))
        pygame.draw.rect(screen, COLORS["blue"], (270, 12, int(100 * self.player.thirst/100), 15))
        
        # 精力值
        energy_text = self.font_small.render(f"⚡ {self.player.energy}", True, COLORS["gold"])
        screen.blit(energy_text, (200, 32))
        pygame.draw.rect(screen, (60, 60, 0), (270, 34, 100, 15))
        pygame.draw.rect(screen, COLORS["gold"], (270, 34, int(100 * self.player.energy/100), 15))
        
        # 天数
        day_text = self.font_small.render(f"📅 第 {self.player.day} 天", True, COLORS["white"])
        screen.blit(day_text, (WINDOW_WIDTH - 120, 10))
        
        # 背包
        inv_text = self.font_small.render(f"🎒 背包: {len(self.player.inventory)}/{self.player.max_inventory}", True, COLORS["white"])
        screen.blit(inv_text, (WINDOW_WIDTH - 180, 32))
        
        # 底部快捷操作
        controls = [
            ("WASD", "移动"),
            ("空格", "采集"),
            ("E", "进食"),
            ("R", "喝水"),
            ("C", "合成"),
            ("H", "帮助"),
            ("P", "暂停"),
        ]
        x_offset = 10
        for key, action in controls:
            text = f"{key}:{action}"
            text_surf = self.font_small.render(text, True, COLORS["light_gray"])
            screen.blit(text_surf, (x_offset, WINDOW_HEIGHT - 50))
            x_offset += text_surf.get_width() + 15
    
    def render_help(self):
        overlay = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT))
        overlay.set_alpha(100)
        overlay.fill((0, 0, 0))
        screen.blit(overlay, (0, 0))
        
        help_y = 100
        help_texts = [
            "🏝️ 荒岛求生指南",
            "",
            "🎯 目标：在荒岛上生存下去！",
            "",
            "⌨️ 控制：",
            "  WASD - 移动角色",
            "  空格 - 采集资源（靠近资源时）",
            "  E - 进食（需要食物）",
            "  R - 喝水（需要水）",
            "  C - 合成工具（石斧等）",
            "  H - 切换帮助",
            "  P - 暂停游戏",
            "",
            "🔄 资源会重生，请合理采集",
            "💡 保持饥饿和口渴值不要为0",
            "",
            "按 H 关闭帮助"
        ]
        
        for text in help_texts:
            color = COLORS["gold"] if "🏝️" in text else COLORS["white"]
            if "⌨️" in text or "🎯" in text:
                size = self.font_medium
            elif "🏝️" in text:
                size = self.font_large
            else:
                size = self.font_small
            
            text_surf = size.render(text, True, color)
            text_rect = text_surf.get_rect(center=(WINDOW_WIDTH//2, help_y))
            screen.blit(text_surf, text_rect)
            help_y += 30
    
    def render_game_over(self):
        overlay = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT))
        overlay.set_alpha(180)
        overlay.fill((0, 0, 0))
        screen.blit(overlay, (0, 0))
        
        end_title = "💀 游戏结束"
        title_surf = self.font_huge.render(end_title, True, COLORS["red"])
        title_rect = title_surf.get_rect(center=(WINDOW_WIDTH//2, 150))
        screen.blit(title_surf, title_rect)
        
        reason_surf = self.font_medium.render(self.game_over_reason, True, COLORS["white"])
        reason_rect = reason_surf.get_rect(center=(WINDOW_WIDTH//2, 220))
        screen.blit(reason_surf, reason_rect)
        
        stats_y = 280
        stats = [
            f"📅 生存天数: {self.player.day} 天",
            f"🎯 采集资源: {sum(self.player.inventory.values())} 个",
            f"❤️ 最终生命: {self.player.health}",
            f"🔧 拥有工具: {sum(1 for v in self.player.tools.values() if v)} 件",
        ]
        
        for stat in stats:
            stat_surf = self.font_medium.render(stat, True, COLORS["gold"])
            stat_rect = stat_surf.get_rect(center=(WINDOW_WIDTH//2, stats_y))
            screen.blit(stat_surf, stat_rect)
            stats_y += 40
        
        restart_text = "按 R 键重新开始"
        restart_surf = self.font_medium.render(restart_text, True, COLORS["green"])
        restart_rect = restart_surf.get_rect(center=(WINDOW_WIDTH//2, 480))
        screen.blit(restart_surf, restart_rect)
    
    def restart_game(self):
        self.player = Player(self.world_width//2, self.world_height//2)
        self.island = IslandGenerator(self.world_width, self.world_height)
        self.is_game_over = False
        self.game_over_reason = ""
        self.messages = []
        self.add_message("🏝️ 新的生存挑战开始！", COLORS["gold"])

# ========== 主循环 ==========
def main():
    game = SurvivalGame()
    game.add_message("🏝️ 欢迎来到荒岛！努力生存下去吧！", COLORS["gold"])
    game.add_message("💡 按 H 查看帮助", COLORS["light_gray"])
    
    while game.is_running:
        game.handle_events()
        game.update()
        game.render()
        clock.tick(FPS)
    
    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()