import pygame
import sys
import random
import math
from pygame.locals import *

# 初始化 Pygame
pygame.init()

# 游戏窗口设置
WIDTH, HEIGHT = 1000, 700
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("荒岛求生")

# 颜色定义
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 50, 50)
GREEN = (50, 200, 50)
BLUE = (50, 150, 255)
YELLOW = (255, 200, 50)
BROWN = (139, 90, 43)
SAND = (238, 214, 175)
OCEAN_BLUE = (0, 120, 190)
DARK_GREEN = (0, 100, 0)
SKY_BLUE = (135, 206, 235)
GRAY = (100, 100, 100)
LIGHT_GRAY = (200, 200, 200)
DARK_GRAY = (50, 50, 50)
ORANGE = (255, 165, 0)
WOOD_BROWN = (139, 90, 43)
ROCK_GRAY = (120, 120, 120)
LEAF_GREEN = (60, 180, 60)
COCONUT_BROWN = (139, 90, 0)
FIRE_ORANGE = (255, 140, 0)
WATER_BLUE = (30, 144, 255)
PLAYER_SKIN = (238, 207, 180)

# 加载字体
try:
    font_large = pygame.font.Font(None, 48)
    font_medium = pygame.font.Font(None, 36)
    font_small = pygame.font.Font(None, 28)
    font_tiny = pygame.font.Font(None, 20)
except:
    font_large = pygame.font.SysFont(None, 48)
    font_medium = pygame.font.SysFont(None, 36)
    font_small = pygame.font.SysFont(None, 28)
    font_tiny = pygame.font.SysFont(None, 20)

# 游戏参数
CELL_SIZE = 50
GRID_WIDTH = 20
GRID_HEIGHT = 14
PLAYER_SPEED = 3
FPS = 60
DAY_LENGTH = 1200  # 一天的长度（帧数）

class Player:
    """玩家类"""
    def __init__(self):
        self.x = GRID_WIDTH // 2 * CELL_SIZE
        self.y = GRID_HEIGHT // 2 * CELL_SIZE
        self.width = 30
        self.height = 45
        self.health = 100
        self.hunger = 100
        self.thirst = 100
        self.energy = 100
        self.direction = (1, 0)
        self.animation_frame = 0
        self.is_moving = False
        
        # 背包
        self.inventory = {
            "wood": 0,
            "stone": 0,
            "coconut": 0,
            "fish": 0,
            "water": 0
        }
        
        # 工具
        self.has_axe = False
        self.has_fishing_rod = False
        
        # 建筑
        self.has_shelter = False
        self.has_fire = False
        self.shelter_x = 0
        self.shelter_y = 0
        self.fire_x = 0
        self.fire_y = 0
        
    def update(self, keys):
        """更新玩家状态"""
        self.animation_frame += 1
        
        # 移动
        dx, dy = 0, 0
        if keys[K_w] or keys[K_UP]:
            dy = -1
        if keys[K_s] or keys[K_DOWN]:
            dy = 1
        if keys[K_a] or keys[K_LEFT]:
            dx = -1
        if keys[K_d] or keys[K_RIGHT]:
            dx = 1
        
        # 更新方向
        if dx != 0 or dy != 0:
            self.direction = (dx, dy)
            self.is_moving = True
        else:
            self.is_moving = False
        
        # 标准化对角线移动
        if dx != 0 and dy != 0:
            dx *= 0.707
            dy *= 0.707
        
        # 移动玩家
        new_x = self.x + dx * PLAYER_SPEED
        new_y = self.y + dy * PLAYER_SPEED
        
        # 边界检查
        if 0 <= new_x <= (GRID_WIDTH * CELL_SIZE - self.width):
            self.x = new_x
        if 0 <= new_y <= (GRID_HEIGHT * CELL_SIZE - self.height):
            self.y = new_y
        
        # 更新状态
        if dx != 0 or dy != 0:
            self.energy = max(0, self.energy - 0.1)
            self.hunger = max(0, self.hunger - 0.05)
            self.thirst = max(0, self.thirst - 0.08)
        else:
            self.energy = min(100, self.energy + 0.3)
        
        # 在庇护所中恢复更快
        if self.has_shelter and abs(self.x - self.shelter_x) < 100 and abs(self.y - self.shelter_y) < 100:
            self.energy = min(100, self.energy + 0.2)
        
        # 在火堆旁恢复健康
        if self.has_fire and abs(self.x - self.fire_x) < 100 and abs(self.y - self.fire_y) < 100:
            self.health = min(100, self.health + 0.1)
        
        # 饥饿和口渴影响健康
        if self.hunger <= 0:
            self.health = max(0, self.health - 0.3)
        if self.thirst <= 0:
            self.health = max(0, self.health - 0.5)
    
    def eat(self, food_type):
        """吃东西"""
        if food_type == "coconut" and self.inventory["coconut"] > 0:
            self.inventory["coconut"] -= 1
            self.hunger = min(100, self.hunger + 40)
            return True
        elif food_type == "fish" and self.inventory["fish"] > 0:
            self.inventory["fish"] -= 1
            self.hunger = min(100, self.hunger + 60)
            return True
        return False
    
    def drink(self):
        """喝水"""
        if self.inventory["water"] > 0:
            self.inventory["water"] -= 1
            self.thirst = min(100, self.thirst + 50)
            return True
        return False
    
    def collect_resource(self, resource_type, amount=1):
        """收集资源"""
        if resource_type in self.inventory:
            self.inventory[resource_type] += amount
            return True
        return False
    
    def can_build(self, item_type):
        """检查是否可以建造/制作"""
        requirements = {
            "axe": {"wood": 3, "stone": 2},
            "fishing_rod": {"wood": 2},
            "shelter": {"wood": 10, "leaf": 5},
            "fire": {"wood": 5, "stone": 3}
        }
        
        if item_type in requirements:
            for resource, amount in requirements[item_type].items():
                if resource == "leaf":
                    if self.inventory["wood"] < amount:
                        return False
                elif self.inventory[resource] < amount:
                    return False
            return True
        return False
    
    def build(self, item_type, x, y):
        """建造/制作"""
        if self.can_build(item_type):
            requirements = {
                "axe": {"wood": 3, "stone": 2},
                "fishing_rod": {"wood": 2},
                "shelter": {"wood": 10, "leaf": 5},
                "fire": {"wood": 5, "stone": 3}
            }
            
            for resource, amount in requirements[item_type].items():
                if resource == "leaf":
                    self.inventory["wood"] -= amount
                else:
                    self.inventory[resource] -= amount
            
            if item_type == "axe":
                self.has_axe = True
            elif item_type == "fishing_rod":
                self.has_fishing_rod = True
            elif item_type == "shelter":
                self.has_shelter = True
                self.shelter_x = x
                self.shelter_y = y
            elif item_type == "fire":
                self.has_fire = True
                self.fire_x = x
                self.fire_y = y
            
            return True
        return False
    
    def draw(self, screen):
        """绘制玩家"""
        x, y = int(self.x), int(self.y)
        
        # 身体
        pygame.draw.rect(screen, PLAYER_SKIN, (x, y, self.width, self.height))
        
        # 头部
        head_radius = self.width // 2
        head_x = x + self.width // 2
        head_y = y - head_radius // 2
        pygame.draw.circle(screen, PLAYER_SKIN, (head_x, head_y), head_radius)
        
        # 眼睛
        eye_radius = 3
        pygame.draw.circle(screen, BLACK, (head_x - 5, head_y - 3), eye_radius)
        pygame.draw.circle(screen, BLACK, (head_x + 5, head_y - 3), eye_radius)
        
        # 嘴巴
        if self.hunger < 30 or self.thirst < 30:
            pygame.draw.arc(screen, RED, (head_x - 8, head_y, 16, 10), 3.14, 0, 2)
        else:
            pygame.draw.arc(screen, RED, (head_x - 8, head_y + 5, 16, 8), 0, 3.14, 2)
        
        # 手臂摆动
        if self.is_moving:
            arm_swing = math.sin(self.animation_frame * 0.2) * 15
        else:
            arm_swing = 0
        
        # 手臂
        arm_color = (218, 187, 160)
        pygame.draw.line(screen, arm_color, (x, y + 15), 
                        (x - 10, y + 15 + arm_swing), 8)
        pygame.draw.line(screen, arm_color, (x + self.width, y + 15), 
                        (x + self.width + 10, y + 15 - arm_swing), 8)
        
        # 腿部
        if self.is_moving:
            leg_swing = math.sin(self.animation_frame * 0.2 + 3.14) * 20
        else:
            leg_swing = 0
        
        leg_color = (198, 167, 140)
        pygame.draw.line(screen, leg_color, (x + 8, y + self.height), 
                        (x, y + self.height + 25 + leg_swing), 8)
        pygame.draw.line(screen, leg_color, (x + self.width - 8, y + self.height), 
                        (x + self.width, y + self.height + 25 - leg_swing), 8)
        
        # 绘制手持工具
        if self.has_axe:
            pygame.draw.rect(screen, WOOD_BROWN, (x + 25, y - 8, 4, 20))
            pygame.draw.polygon(screen, ROCK_GRAY, 
                              [(x + 29, y - 8), (x + 40, y - 8), (x + 29, y + 8)])
    
    def get_rect(self):
        """获取玩家矩形"""
        return pygame.Rect(self.x, self.y, self.width, self.height)

class Resource:
    """资源类"""
    def __init__(self, x, y, resource_type):
        self.x = x
        self.y = y
        self.type = resource_type
        self.amount = random.randint(3, 6)
        self.collected = False
        self.regrow_timer = random.randint(300, 600)
        
        if resource_type == "tree":
            self.width = 40
            self.height = 60
        elif resource_type == "rock":
            self.width = 35
            self.height = 30
        elif resource_type == "coconut":
            self.width = 40
            self.height = 70
        elif resource_type == "fish":
            self.width = 30
            self.height = 15
        elif resource_type == "water":
            self.width = 40
            self.height = 20
    
    def update(self):
        """更新资源"""
        if self.collected:
            self.regrow_timer -= 1
            if self.regrow_timer <= 0:
                self.collected = False
                self.amount = random.randint(3, 6)
    
    def draw(self, screen):
        """绘制资源"""
        if self.collected:
            return
            
        if self.type == "tree":
            # 树干
            pygame.draw.rect(screen, WOOD_BROWN, (self.x + 15, self.y + 20, 10, 40))
            # 树冠
            pygame.draw.circle(screen, LEAF_GREEN, (self.x + 20, self.y + 10), 15)
            # 数量
            amount_text = font_tiny.render(str(self.amount), True, WHITE)
            screen.blit(amount_text, (self.x + 15, self.y))
                
        elif self.type == "rock":
            pygame.draw.ellipse(screen, ROCK_GRAY, (self.x, self.y, self.width, self.height))
            pygame.draw.ellipse(screen, DARK_GRAY, (self.x, self.y, self.width, self.height), 2)
            amount_text = font_tiny.render(str(self.amount), True, WHITE)
            screen.blit(amount_text, (self.x + 10, self.y - 10))
                
        elif self.type == "coconut":
            # 树干
            pygame.draw.rect(screen, WOOD_BROWN, (self.x + 15, self.y + 20, 10, 50))
            # 树冠
            pygame.draw.circle(screen, LEAF_GREEN, (self.x + 20, self.y + 10), 12)
            # 椰子
            for i in range(2):
                coconut_x = self.x + 10 + i * 15
                coconut_y = self.y + 15
                pygame.draw.circle(screen, COCONUT_BROWN, (coconut_x, coconut_y), 6)
            amount_text = font_tiny.render(str(self.amount), True, WHITE)
            screen.blit(amount_text, (self.x + 15, self.y))
                
        elif self.type == "fish":
            # 鱼
            pygame.draw.ellipse(screen, (200, 200, 100), (self.x, self.y, 25, 10))
            pygame.draw.polygon(screen, (200, 200, 100), 
                              [(self.x + 25, self.y + 5), (self.x + 35, self.y), (self.x + 35, self.y + 10)])
            # 鱼鳍
            pygame.draw.polygon(screen, (180, 180, 80),
                              [(self.x + 10, self.y), (self.x + 15, self.y - 5), (self.x + 20, self.y)])
            # 鱼眼睛
            pygame.draw.circle(screen, BLACK, (self.x + 5, self.y + 3), 2)
                
        elif self.type == "water":
            # 水
            pygame.draw.ellipse(screen, WATER_BLUE, (self.x, self.y, self.width, self.height))
            # 波纹
            for i in range(3):
                wave_y = self.y + 5 + i * 5
                pygame.draw.ellipse(screen, (200, 230, 255), (self.x + 5, wave_y, 30, 5), 1)
    
    def get_rect(self):
        """获取资源矩形"""
        return pygame.Rect(self.x, self.y, self.width, self.height)
    
    def collect(self, player, has_tool=False):
        """收集资源"""
        if self.collected or self.amount <= 0:
            return False
            
        collected = False
        if self.type == "tree":
            if has_tool:
                self.amount -= 1
                player.collect_resource("wood", 1)
                collected = True
                
        elif self.type == "rock":
            self.amount -= 1
            player.collect_resource("stone", 1)
            collected = True
                
        elif self.type == "coconut":
            self.amount -= 1
            player.collect_resource("coconut", 1)
            collected = True
            
        elif self.type == "fish":
            if has_tool:
                self.amount -= 1
                player.collect_resource("fish", 1)
                collected = True
            
        elif self.type == "water":
            if player.inventory["water"] < 10:  # 限制携带水量
                self.amount -= 1
                player.collect_resource("water", 1)
                collected = True
        
        if self.amount <= 0:
            self.collected = True
        
        return collected

class Structure:
    """建筑类"""
    def __init__(self, x, y, structure_type):
        self.x = x
        self.y = y
        self.type = structure_type
        
    def draw(self, screen):
        """绘制建筑"""
        if self.type == "shelter":
            # 庇护所
            pygame.draw.rect(screen, WOOD_BROWN, (self.x, self.y, 60, 40))
            # 屋顶
            roof_points = [(self.x, self.y), (self.x + 60, self.y), (self.x + 30, self.y - 20)]
            pygame.draw.polygon(screen, BROWN, roof_points)
            # 门口
            pygame.draw.rect(screen, DARK_BROWN, (self.x + 20, self.y + 20, 20, 20))
            
        elif self.type == "fire":
            # 篝火
            for i in range(3):
                flame_height = 10 + i * 5
                flame_width = 8 - i * 2
                flame_color = (255, 100 + i*20, 0)
                flame_points = [
                    (self.x + 15, self.y - i*3),
                    (self.x + 15 - flame_width, self.y + flame_height),
                    (self.x + 15 + flame_width, self.y + flame_height)
                ]
                pygame.draw.polygon(screen, flame_color, flame_points)
            pygame.draw.rect(screen, WOOD_BROWN, (self.x, self.y + 10, 30, 5))

class Game:
    """游戏主类"""
    def __init__(self):
        self.player = None
        self.resources = []
        self.structures = []
        self.day = 1
        self.day_time = 0
        self.is_night = False
        self.raining = False
        self.game_state = "start"  # start, playing, game_over, victory
        self.message = ""
        self.message_timer = 0
        self.days_survived = 0
        self.rain_timer = 0
        
        self.init_game()
    
    def init_game(self):
        """初始化游戏"""
        self.player = Player()
        self.resources = []
        self.structures = []
        self.day = 1
        self.day_time = 0
        self.is_night = False
        self.raining = False
        self.days_survived = 0
        self.message = ""
        self.message_timer = 0
        self.rain_timer = 0
        
        # 生成资源
        self.generate_resources()
    
    def generate_resources(self):
        """生成资源"""
        # 树木
        for _ in range(12):
            x = random.randint(3, GRID_WIDTH - 2) * CELL_SIZE
            y = random.randint(3, GRID_HEIGHT - 2) * CELL_SIZE
            self.resources.append(Resource(x, y, "tree"))
        
        # 岩石
        for _ in range(10):
            x = random.randint(2, GRID_WIDTH - 2) * CELL_SIZE
            y = random.randint(2, GRID_HEIGHT - 2) * CELL_SIZE
            self.resources.append(Resource(x, y, "rock"))
        
        # 椰子树
        for _ in range(8):
            x = random.randint(1, 5) * CELL_SIZE
            y = random.randint(2, 5) * CELL_SIZE
            self.resources.append(Resource(x, y, "coconut"))
        
        # 鱼
        for _ in range(6):
            x = random.randint(0, 4) * CELL_SIZE
            y = random.randint(0, 2) * CELL_SIZE
            self.resources.append(Resource(x, y, "fish"))
        
        # 水源
        for _ in range(4):
            x = random.randint(1, GRID_WIDTH - 2) * CELL_SIZE
            y = random.randint(1, 3) * CELL_SIZE
            self.resources.append(Resource(x, y, "water"))
    
    def update(self):
        """更新游戏状态"""
        if self.game_state != "playing":
            return
        
        # 更新玩家
        keys = pygame.key.get_pressed()
        self.player.update(keys)
        
        # 检查死亡
        if self.player.health <= 0:
            self.game_state = "game_over"
            return
        
        # 更新时间
        self.day_time += 1
        if self.day_time >= DAY_LENGTH:
            self.day_time = 0
            self.day += 1
            self.days_survived += 1
            # 每天消耗
            self.player.hunger = max(0, self.player.hunger - 25)
            self.player.thirst = max(0, self.player.thirst - 35)
        
        # 检查夜晚
        self.is_night = (self.day_time > DAY_LENGTH * 0.7)
        
        # 更新天气
        self.rain_timer -= 1
        if self.rain_timer <= 0:
            self.raining = not self.raining
            self.rain_timer = random.randint(300, 900)
        
        # 更新资源
        for resource in self.resources:
            resource.update()
        
        # 更新消息计时器
        if self.message_timer > 0:
            self.message_timer -= 1
        
        # 检查胜利条件
        if self.days_survived >= 7:  # 生存7天
            self.game_state = "victory"
    
    def show_message(self, message):
        """显示消息"""
        self.message = message
        self.message_timer = 120  # 2秒
    
    def handle_collection(self):
        """处理资源收集"""
        player_rect = self.player.get_rect()
        for resource in self.resources:
            if not resource.collected and resource.amount > 0:
                if player_rect.colliderect(resource.get_rect()):
                    if resource.type == "tree":
                        collected = resource.collect(self.player, self.player.has_axe)
                        if collected:
                            self.show_message("收集了木材")
                        else:
                            self.show_message("需要斧头")
                    elif resource.type == "rock":
                        collected = resource.collect(self.player, True)
                        if collected:
                            self.show_message("收集了石头")
                    elif resource.type == "coconut":
                        collected = resource.collect(self.player, True)
                        if collected:
                            self.show_message("收集了椰子")
                    elif resource.type == "fish":
                        collected = resource.collect(self.player, self.player.has_fishing_rod)
                        if collected:
                            self.show_message("捕获了鱼")
                        else:
                            self.show_message("需要鱼竿")
                    elif resource.type == "water":
                        collected = resource.collect(self.player, True)
                        if collected:
                            self.show_message("收集了水")
                    break
    
    def handle_eating(self, food_type):
        """处理吃东西"""
        if self.player.eat(food_type):
            if food_type == "coconut":
                self.show_message("吃了椰子，恢复了饥饿")
            elif food_type == "fish":
                self.show_message("吃了鱼，恢复了饥饿")
        else:
            self.show_message(f"没有{ '椰子' if food_type == 'coconut' else '鱼' }")
    
    def handle_drinking(self):
        """处理喝水"""
        if self.player.drink():
            self.show_message("喝了水，解除了口渴")
        else:
            self.show_message("没有水")
    
    def handle_building(self, item_type):
        """处理建造/制作"""
        if item_type in ["shelter", "fire"]:
            # 建造建筑
            if self.player.can_build(item_type):
                x, y = self.player.x, self.player.y
                if self.player.build(item_type, x, y):
                    self.structures.append(Structure(x, y, item_type))
                    if item_type == "shelter":
                        self.show_message("建造了庇护所")
                    elif item_type == "fire":
                        self.show_message("生起了篝火")
                else:
                    self.show_message("建造失败")
            else:
                self.show_message("资源不足")
        else:
            # 制作工具
            if self.player.can_build(item_type):
                if self.player.build(item_type, 0, 0):
                    if item_type == "axe":
                        self.show_message("制作了斧头")
                    elif item_type == "fishing_rod":
                        self.show_message("制作了鱼竿")
                else:
                    self.show_message("制作失败")
            else:
                self.show_message("资源不足")
    
    def draw(self, screen):
        """绘制游戏"""
        # 绘制背景
        if self.is_night:
            screen.fill((0, 0, 40))  # 夜晚
        else:
            screen.fill(SKY_BLUE)  # 白天
        
        # 绘制海洋
        pygame.draw.rect(screen, OCEAN_BLUE, (0, 0, WIDTH, 100))
        
        # 绘制沙滩
        pygame.draw.rect(screen, SAND, (0, 100, WIDTH, 60))
        
        # 绘制草地
        for y in range(160, HEIGHT, 20):
            for x in range(0, WIDTH, 20):
                color_variation = random.randint(-20, 20)
                grass_color = (
                    max(0, min(255, DARK_GREEN[0] + color_variation)),
                    max(0, min(255, DARK_GREEN[1] + color_variation)),
                    max(0, min(255, DARK_GREEN[2] + color_variation))
                )
                pygame.draw.rect(screen, grass_color, (x, y, 20, 20))
        
        # 绘制雨水
        if self.raining:
            for _ in range(30):
                rain_x = random.randint(0, WIDTH)
                rain_y = (random.randint(0, HEIGHT) + pygame.time.get_ticks() // 10) % HEIGHT
                pygame.draw.line(screen, WATER_BLUE, (rain_x, rain_y), (rain_x, rain_y + 10), 1)
        
        # 绘制资源
        for resource in self.resources:
            resource.draw(screen)
        
        # 绘制建筑
        for structure in self.structures:
            structure.draw(screen)
        
        # 绘制玩家
        self.player.draw(screen)
        
        # 绘制HUD
        self.draw_hud(screen)
        
        # 绘制消息
        if self.message_timer > 0:
            message_surface = pygame.Surface((WIDTH, 40), pygame.SRCALPHA)
            message_surface.fill((0, 0, 0, 180))
            screen.blit(message_surface, (0, HEIGHT - 100))
            message_text = font_small.render(self.message, True, YELLOW)
            screen.blit(message_text, (WIDTH//2 - message_text.get_width()//2, HEIGHT - 85))
        
        # 绘制游戏状态界面
        if self.game_state == "start":
            self.draw_start_screen(screen)
        elif self.game_state == "game_over":
            self.draw_game_over_screen(screen)
        elif self.game_state == "victory":
            self.draw_victory_screen(screen)
    
    def draw_hud(self, screen):
        """绘制游戏信息界面"""
        # 绘制半透明背景
        hud_bg = pygame.Surface((WIDTH, 120), pygame.SRCALPHA)
        hud_bg.fill((0, 0, 0, 180))
        screen.blit(hud_bg, (0, 0))
        
        # 绘制状态条
        bars = [
            ("健康", self.player.health, RED, 20, 20),
            ("饥饿", self.player.hunger, ORANGE, 20, 50),
            ("口渴", self.player.thirst, BLUE, 20, 80)
        ]
        
        for name, value, color, x, y in bars:
            # 标签
            label_text = font_small.render(f"{name}: {int(value)}", True, WHITE)
            screen.blit(label_text, (x, y - 5))
            
            # 进度条
            bar_width = 180
            bar_height = 12
            pygame.draw.rect(screen, DARK_GRAY, (x, y + 20, bar_width, bar_height))
            fill_width = int(bar_width * (value / 100))
            pygame.draw.rect(screen, color, (x, y + 20, fill_width, bar_height))
        
        # 绘制能量
        energy_text = font_small.render(f"能量: {int(self.player.energy)}", True, WHITE)
        screen.blit(energy_text, (220, 20))
        
        # 绘制天数
        time_of_day = "🌙夜晚" if self.is_night else "☀️白天"
        day_text = font_small.render(f"第{self.day}天 {time_of_day}", True, WHITE)
        screen.blit(day_text, (WIDTH - 220, 20))
        
        # 绘制天气
        weather = "🌧️下雨" if self.raining else "☀️晴天"
        weather_text = font_small.render(f"天气: {weather}", True, WHITE)
        screen.blit(weather_text, (WIDTH - 220, 50))
        
        # 绘制生存天数
        survive_text = font_small.render(f"已生存: {self.days_survived}天", True, GREEN)
        screen.blit(survive_text, (WIDTH - 220, 80))
        
        # 绘制库存
        inventory_x = 350
        inventory_y = 20
        
        inventory_text = font_small.render("📦 背包:", True, WHITE)
        screen.blit(inventory_text, (inventory_x, inventory_y))
        
        resources = [
            ("wood", "🪵 木材", WOOD_BROWN),
            ("stone", "🪨 石头", ROCK_GRAY),
            ("coconut", "🥥 椰子", COCONUT_BROWN),
            ("fish", "🐟 鱼", (200, 200, 100)),
            ("water", "💧 水", WATER_BLUE)
        ]
        
        for i, (key, name, color) in enumerate(resources):
            y = inventory_y + 30 + i * 25
            resource_text = font_small.render(f"{name}: {self.player.inventory[key]}", True, color)
            screen.blit(resource_text, (inventory_x, y))
        
        # 绘制工具
        tools_x = 600
        tools_y = 20
        
        tools_text = font_small.render("🛠️ 工具:", True, WHITE)
        screen.blit(tools_text, (tools_x, tools_y))
        
        tool_status = [
            ("🪓 斧头", self.player.has_axe),
            ("🎣 鱼竿", self.player.has_fishing_rod)
        ]
        
        for i, (name, has_tool) in enumerate(tool_status):
            y = tools_y + 30 + i * 25
            color = GREEN if has_tool else RED
            status = "✓" if has_tool else "✗"
            tool_text = font_small.render(f"{name}: {status}", True, color)
            screen.blit(tool_text, (tools_x, y))
        
        # 绘制建筑
        buildings_x = 770
        buildings_y = 20
        
        buildings_text = font_small.render("🏠 建筑:", True, WHITE)
        screen.blit(buildings_text, (buildings_x, buildings_y))
        
        building_status = [
            ("庇护所", self.player.has_shelter),
            ("篝火", self.player.has_fire)
        ]
        
        for i, (name, has_building) in enumerate(building_status):
            y = buildings_y + 30 + i * 25
            color = GREEN if has_building else RED
            status = "✓" if has_building else "✗"
            building_text = font_small.render(f"{name}: {status}", True, color)
            screen.blit(building_text, (buildings_x, y))
        
        # 绘制控制提示
        controls = [
            "WASD/方向键: 移动",
            "E: 收集资源",
            "1: 吃椰子",
            "2: 吃鱼",
            "3: 喝水",
            "Q: 制作斧头",
            "F: 制作鱼竿",
            "Z: 建造庇护所",
            "X: 生起篝火",
            "ESC: 菜单"
        ]
        
        for i, control in enumerate(controls):
            control_text = font_tiny.render(control, True, LIGHT_GRAY)
            screen.blit(control_text, (WIDTH - 220, HEIGHT - 120 + i * 20))
    
    def draw_start_screen(self, screen):
        """绘制开始画面"""
        overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 220))
        screen.blit(overlay, (0, 0))
        
        title_text = font_large.render("🏝️ 荒岛求生", True, GREEN)
        screen.blit(title_text, (WIDTH//2 - 120, HEIGHT//2 - 150))
        
        instructions = [
            "你被困在一个荒岛上，必须生存7天等待救援",
            "",
            "📊 生存要素:",
            "❤️ 健康: 保持健康才能生存",
            "🍎 饥饿: 收集食物并进食",
            "💧 口渴: 注意水分补充",
            "⚡ 能量: 足够的能量才能行动",
            "",
            "🌳 资源系统:",
            "🪵 树木: 收集木材 (需要斧头🪓)",
            "🪨 岩石: 收集石头",
            "🥥 椰子树: 收集椰子 (食物)",
            "🐟 鱼: 捕捉鱼 (需要鱼竿🎣)",
            "💧 水源: 收集饮用水",
            "",
            "🏠 建造系统:",
            "🏠 庇护所: 提供休息和恢复 (需要木材10+树叶5)",
            "🔥 篝火: 提供温暖和照明 (需要木材5+石头3)",
            "🛠️ 工具: 斧头、鱼竿 (相应资源)",
            "",
            "🎯 目标: 在荒岛上生存7天，等待救援!",
            "",
            "💡 提示: 合理分配资源，注意天气变化!"
        ]
        
        for i, instruction in enumerate(instructions):
            color = YELLOW if i == 0 else WHITE
            instruction_text = font_small.render(instruction, True, color)
            screen.blit(instruction_text, (WIDTH//2 - 350, HEIGHT//2 - 100 + i * 25))
        
        start_text = font_medium.render("按 空格键 开始游戏", True, GREEN)
        screen.blit(start_text, (WIDTH//2 - 120, HEIGHT - 100))
    
    def draw_game_over_screen(self, screen):
        """绘制游戏结束画面"""
        overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 220))
        screen.blit(overlay, (0, 0))
        
        game_over_text = font_large.render("💀 生存失败!", True, RED)
        screen.blit(game_over_text, (WIDTH//2 - 120, HEIGHT//2 - 100))
        
        stats = [
            f"生存天数: {self.days_survived}/7",
            f"最终健康: {int(self.player.health)}",
            f"最终饥饿: {int(self.player.hunger)}",
            f"最终口渴: {int(self.player.thirst)}",
            f"收集木材: {self.player.inventory['wood']}",
            f"收集石头: {self.player.inventory['stone']}"
        ]
        
        for i, stat in enumerate(stats):
            stat_text = font_medium.render(stat, True, WHITE)
            screen.blit(stat_text, (WIDTH//2 - 150, HEIGHT//2 - 50 + i * 40))
        
        restart_text = font_medium.render("按 R 键重新开始", True, GREEN)
        screen.blit(restart_text, (WIDTH//2 - 100, HEIGHT//2 + 150))
        
        menu_text = font_medium.render("按 ESC 键返回菜单", True, YELLOW)
        screen.blit(menu_text, (WIDTH//2 - 120, HEIGHT//2 + 200))
    
    def draw_victory_screen(self, screen):
        """绘制胜利画面"""
        overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 220))
        screen.blit(overlay, (0, 0))
        
        victory_text = font_large.render("🎉 生存成功!", True, YELLOW)
        screen.blit(victory_text, (WIDTH//2 - 120, HEIGHT//2 - 150))
        
        rescue_text = font_medium.render("🚁 救援队找到了你!", True, GREEN)
        screen.blit(rescue_text, (WIDTH//2 - 120, HEIGHT//2 - 100))
        
        stats = [
            f"总生存天数: {self.days_survived}天",
            f"最终健康: {int(self.player.health)}",
            f"最终饥饿: {int(self.player.hunger)}",
            f"最终口渴: {int(self.player.thirst)}",
            f"收集木材: {self.player.inventory['wood']}",
            f"收集石头: {self.player.inventory['stone']}",
            f"建造完成: 庇护所{'✓' if self.player.has_shelter else '✗'} 篝火{'✓' if self.player.has_fire else '✗'}"
        ]
        
        for i, stat in enumerate(stats):
            stat_text = font_medium.render(stat, True, WHITE)
            screen.blit(stat_text, (WIDTH//2 - 150, HEIGHT//2 - 50 + i * 40))
        
        restart_text = font_medium.render("按 R 键重新开始游戏", True, GREEN)
        screen.blit(restart_text, (WIDTH//2 - 140, HEIGHT//2 + 180))
        
        menu_text = font_medium.render("按 ESC 键返回主菜单", True, YELLOW)
        screen.blit(menu_text, (WIDTH//2 - 140, HEIGHT//2 + 230))

def main():
    """主游戏函数"""
    clock = pygame.time.Clock()
    game = Game()
    
    # 主游戏循环
    running = True
    while running:
        clock.tick(FPS)
        
        # 处理事件
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    if game.game_state in ["playing", "game_over", "victory"]:
                        game.game_state = "start"
                    else:
                        running = False
                elif event.key == K_SPACE:
                    if game.game_state == "start":
                        game.game_state = "playing"
                elif event.key == K_r:
                    if game.game_state in ["game_over", "victory"]:
                        game.init_game()
                        game.game_state = "playing"
                elif game.game_state == "playing":
                    if event.key == K_e:
                        game.handle_collection()
                    elif event.key == K_1:
                        game.handle_eating("coconut")
                    elif event.key == K_2:
                        game.handle_eating("fish")
                    elif event.key == K_3:
                        game.handle_drinking()
                    elif event.key == K_q:
                        game.handle_building("axe")
                    elif event.key == K_f:
                        game.handle_building("fishing_rod")
                    elif event.key == K_z:
                        game.handle_building("shelter")
                    elif event.key == K_x:
                        game.handle_building("fire")
        
        # 更新游戏状态
        if game.game_state == "playing":
            game.update()
        
        # 绘制游戏
        game.draw(screen)
        
        pygame.display.flip()
    
    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()