#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 本文件由 360问AI 生成。
"""
🏔️ 硬核荒野求生 - 终极硬核版
================================
PyGame 图形界面生存游戏

新增终极硬核机制：
- ⏱️ 超慢时间流逝（1现实秒 ≈ 0.5游戏分钟）
- 🦴 6部位肢体伤害（流血/骨折/感染/残废）
- 🌗 昼夜交替 + 夜间致命偷袭
- 🧠 精神值系统（幻觉/崩溃）
- 🤒 疾病/中毒/营养不良
- 🍖 食物腐烂系统
- 🌡️ 体温 + 极端天气致命
- 💀 永久残废 + 死亡不可逆
"""

import pygame
import random
import sys
import math
import time as time_module

# ==================== 初始化 ====================
pygame.init()
pygame.font.init()

WIDTH, HEIGHT = 1150, 780
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("🏔️ 硬核荒野求生 — 终极硬核版")
clock = pygame.time.Clock()

def get_font(size):
    for name in ["microsoftyahei", "simhei", "pingfangsc", "heiti sc", "notosanscjksc", "arial"]:
        f = pygame.font.SysFont(name, size)
        if f:
            return f
    return pygame.font.Font(None, size)

font_xs = get_font(13)
font_sm = get_font(16)
font_md = get_font(21)
font_lg = get_font(30)
font_xl = get_font(46)

# 颜色
WHITE   = (255, 255, 255)
BLACK   = (0, 0, 0)
RED     = (220, 50, 50)
GREEN   = (50, 200, 80)
BLUE    = (60, 120, 220)
YELLOW  = (240, 200, 40)
ORANGE  = (240, 140, 40)
CYAN    = (80, 200, 220)
GRAY    = (120, 120, 120)
DKGRAY  = (60, 60, 60)
BROWN   = (140, 90, 50)
DKRED   = (150, 30, 30)
DKGREEN = (30, 100, 40)
DKBLUE  = (20, 40, 80)
PINK    = (220, 100, 150)
PURPLE  = (150, 80, 200)
GOLD    = (255, 215, 0)

# ==================== 时间系统 ★★★超慢速★★★ ====================
DAY_LENGTH = 1440  # 一天 = 1440 游戏分钟

class TimeSystem:
    def __init__(self):
        self.game_minutes = 360.0   # 从早上6:00开始（浮点数，精度更高）
        self.day = 1
        self.season = 0             # 0春 1夏 2秋 3冬
        self.season_names = ["🌸春季", "☀️夏季", "🍂秋季", "❄️冬季"]
        self.season_days = 15       # 每季15天
        self.frame_counter = 0
        # ★★★ 核心：每120帧（约2秒现实时间）才推进1游戏分钟 ★★★
        self.frames_per_minute = 120

    def update(self):
        self.frame_counter += 1
        if self.frame_counter >= self.frames_per_minute:
            self.frame_counter = 0
            self.game_minutes += 1.0
            if self.game_minutes >= DAY_LENGTH:
                self.game_minutes -= DAY_LENGTH
                self.day += 1
                if self.day > self.season_days:
                    self.day = 1
                    self.season = (self.season + 1) % 4

    def get_hour(self):
        return int(self.game_minutes // 60) % 24

    def get_minute(self):
        return int(self.game_minutes % 60)

    def get_time_str(self):
        h, m = self.get_hour(), self.get_minute()
        return f"{h:02d}:{m:02d}"

    def is_night(self):
        h = self.get_hour()
        return h < 6 or h >= 20

    def is_dawn(self):
        return 5 <= self.get_hour() < 7

    def is_dusk(self):
        return 18 <= self.get_hour() < 20

    def get_sky_color(self):
        h = self.get_hour()
        m = self.get_minute()
        t = h + m / 60.0
        if 7 <= t < 17:
            return (135, 200, 250)
        elif 17 <= t < 19:
            f = (t - 17) / 2
            return self._lerp((135, 200, 250), (200, 100, 50), f)
        elif 19 <= t < 20:
            f = t - 19
            return self._lerp((200, 100, 50), (15, 15, 40), f)
        elif 20 <= t or t < 5:
            return (15, 15, 40)
        elif 5 <= t < 6:
            f = t - 5
            return self._lerp((15, 15, 40), (200, 120, 80), f)
        else:
            f = t - 6
            return self._lerp((200, 120, 80), (135, 200, 250), f)

    def get_darkness(self):
        h = self.get_hour()
        m = self.get_minute()
        t = h + m / 60.0
        if 8 <= t < 17:   return 0.0
        elif 17 <= t < 20: return (t - 17) / 3 * 0.7
        elif 20 <= t or t < 5: return 0.7
        elif 5 <= t < 8:  return 0.7 - (t - 5) / 3 * 0.7
        return 0.0

    def _lerp(self, c1, c2, f):
        f = max(0.0, min(1.0, f))
        return tuple(int(c1[i] + (c2[i] - c1[i]) * f) for i in range(3))

    def get_season_name(self):
        return self.season_names[self.season]

    def get_total_days(self):
        return (self.season * self.season_days) + self.day - 1

    def advance(self, minutes):
        """推进指定分钟数"""
        for _ in range(int(minutes)):
            self.game_minutes += 1.0
            if self.game_minutes >= DAY_LENGTH:
                self.game_minutes -= DAY_LENGTH
                self.day += 1
                if self.day > self.season_days:
                    self.day = 1
                    self.season = (self.season + 1) % 4

time_sys = TimeSystem()

# ==================== 天气系统 ====================
class WeatherSystem:
    def __init__(self):
        self.weather = 0
        self.names = ["☀️晴天", "⛅多云", "🌧️小雨", "⛈️暴雨", "🌬️大风", "❄️暴雪"]
        self.timer = 0
        self.change_interval = 600  # 600帧 ≈ 10秒现实 = 5游戏分钟才检查天气变化
        self.particles = []

    def update(self, season):
        self.timer += 1
        if self.timer >= self.change_interval:
            self.timer = 0
            self._change(season)
        self._particles()

    def _change(self, s):
        if s == 3:
            self.weather = random.choices([0,1,2,3,4,5], weights=[8,12,8,8,20,44])[0]
        elif s == 1:
            self.weather = random.choices([0,1,2,3,4], weights=[40,20,15,15,10])[0]
        elif s == 0:
            self.weather = random.choices([0,1,2,3,4], weights=[25,25,25,10,15])[0]
        else:
            self.weather = random.choices([0,1,2,3,4], weights=[20,25,20,10,25])[0]

    def _particles(self):
        w = self.weather
        if w == 2:
            for _ in range(1):
                self.particles.append([random.randint(0,WIDTH), -5, 3, random.randint(8,14), (120,160,220)])
        elif w == 3:
            for _ in range(4):
                self.particles.append([random.randint(0,WIDTH), -5, 5, random.randint(12,20), (80,120,200)])
        elif w == 5:
            for _ in range(1):
                self.particles.append([random.randint(0,WIDTH), -5, random.uniform(0.5,2), random.randint(2,5), (255,255,255)])
        elif w == 4:
            if random.random() < 0.3:
                self.particles.append([-5, random.randint(0,HEIGHT), 6, random.randint(1,3), (180,180,160)])

        new_p = []
        for p in self.particles:
            p[0] += p[2]
            p[1] += p[3] if w != 4 else random.uniform(-0.5, 0.5)
            if p[1] < HEIGHT + 10 and p[0] < WIDTH + 10:
                new_p.append(p)
        self.particles = new_p[-250:]

    def get_name(self):
        return self.names[self.weather]

    def draw(self, surface):
        for p in self.particles:
            if self.weather in [2,3]:
                pygame.draw.line(surface, p[4], (int(p[0]), int(p[1])),
                               (int(p[0])-1, int(p[1])+int(p[3])), 1)
            elif self.weather == 5:
                pygame.draw.circle(surface, p[4], (int(p[0]), int(p[1])), int(p[3]))
            elif self.weather == 4:
                pygame.draw.line(surface, p[4], (int(p[0]), int(p[1])),
                               (int(p[0])+8, int(p[1])), 1)

weather = WeatherSystem()

# ==================== 肢体系统 ★★★核心★★★ ====================
class BodyPart:
    def __init__(self, name, max_hp, critical=False):
        self.name = name
        self.max_hp = max_hp
        self.hp = max_hp
        self.critical = critical
        self.bleeding = False
        self.broken = False
        self.infected = False
        self.disabled = False
        self.bandaged = False
        self.frostbitten = False   # ★ 冻伤
        self.burn_level = 0        # 0无 1轻 2重 烧伤

    def take_damage(self, dmg):
        if self.disabled:
            return 0
        actual = min(self.hp, max(0, dmg))
        self.hp = max(0, self.hp - actual)
        if self.hp <= 0:
            self.disabled = True
            self.bleeding = False
        # 流血
        if actual > 4 and random.random() < 0.45:
            self.bleeding = True
        # 骨折
        if actual > 12 and random.random() < 0.3:
            self.broken = True
        # 重伤感染
        if self.broken and self.bleeding and random.random() < 0.35:
            self.infected = True
        return actual

    def heal(self, amt):
        if self.disabled:
            return 0
        old = self.hp
        self.hp = min(self.max_hp, self.hp + amt)
        return self.hp - old

    def treat_bleed(self):
        self.bleeding = False
        self.bandaged = True

    def fix_bone(self):
        self.broken = False

    def treat_infection(self):
        self.infected = False

    def color(self):
        if self.disabled: return (50,50,50)
        if self.frostbitten: return (100, 150, 255)
        r = self.hp / self.max_hp
        if r > 0.7:   return (80, 200, 80)
        elif r > 0.4: return (220, 200, 50)
        elif r > 0.15:return (220, 120, 50)
        else:         return (220, 40, 40)

    def icons(self):
        ic = []
        if self.bleeding:    ic.append("🩸")
        if self.broken:      ic.append("🦴")
        if self.infected:    ic.append("🦠")
        if self.frostbitten: ic.append("🥶")
        if self.disabled:    ic.append("💀")
        return ic

class Body:
    def __init__(self):
        self.parts = {
            'head':  BodyPart("头部", 80, critical=True),
            'torso': BodyPart("躯干", 160, critical=True),
            'l_arm': BodyPart("左臂", 65),
            'r_arm': BodyPart("右臂", 65),
            'l_leg': BodyPart("左腿", 65),
            'r_leg': BodyPart("右腿", 65),
        }

    def random_part(self, w=None):
        if w is None:
            w = {'head':10,'torso':35,'l_arm':14,'r_arm':14,'l_leg':14,'r_leg':13}
        return random.choices(list(w.keys()), weights=list(w.values()))[0]

    def total_hp(self):
        return sum(p.hp for p in self.parts.values())

    def total_max(self):
        return sum(p.max_hp for p in self.parts.values())

    def alive(self):
        return self.parts['torso'].hp > 0 and self.parts['head'].hp > 0

    def atk_mod(self):
        m = 1.0
        for a in ['l_arm','r_arm']:
            p = self.parts[a]
            if p.disabled: m *= 0.3
            elif p.broken: m *= 0.45
            if p.bleeding: m *= 0.8
        if self.parts['head'].hp < self.parts['head'].max_hp * 0.3:
            m *= 0.5
        return max(0.1, m)

    def gather_mod(self):
        m = 1.0
        arms = sum(1 for a in ['l_arm','r_arm'] if not self.parts[a].disabled)
        m *= (0.3 + 0.35 * arms)
        for a in ['l_arm','r_arm']:
            if self.parts[a].broken: m *= 0.5
        return max(0.1, m)

    def move_mod(self):
        m = 1.0
        legs = sum(1 for l in ['l_leg','r_leg'] if not self.parts[l].disabled)
        m *= (0.3 + 0.35 * legs)
        for l in ['l_leg','r_leg']:
            if self.parts[l].broken: m *= 0.45
        return max(0.1, m)

    def tick(self):
        """周期性伤害处理"""
        for k, p in self.parts.items():
            if p.bleeding:
                p.hp = max(0, p.hp - 1)
                if p.hp <= 0:
                    p.disabled = True
                    p.bleeding = False
            if p.infected:
                p.hp = max(0, p.hp - 2)
                if p.hp <= 0:
                    p.disabled = True
                    p.infected = False
                if k != 'torso' and random.random() < 0.04:
                    self.parts['torso'].infected = True
            if p.frostbitten and random.random() < 0.08:
                p.hp = max(0, p.hp - 1)
                if p.hp <= 0:
                    p.disabled = True
        return self.alive()

    def draw(self, surface, x, y):
        t = font_sm.render("肢体状态", True, WHITE)
        surface.blit(t, (x-10, y)); y += 22

        def label(part, lx, ly):
            ns = font_xs.render(f"{part.name} {part.hp}/{part.max_hp}", True, WHITE)
            surface.blit(ns, (lx, ly))
            ic = part.icons()
            if ic:
                ims = font_xs.render(" ".join(ic), True, RED)
                surface.blit(ims, (lx, ly + 14))

        # 头
        hp = self.parts['head']; c = hp.color()
        pygame.draw.circle(surface, c, (x+30, y+15), 15, 2)
        pygame.draw.circle(surface, c, (x+30, y+15), 14)
        label(hp, x+50, y+8); y += 35

        # 躯干
        tp = self.parts['torso']; c = tp.color()
        pygame.draw.rect(surface, c, (x+10, y, 40, 55), 2)
        pygame.draw.rect(surface, c, (x+11, y+1, 38, 53))
        label(tp, x+55, y+20)

        # 左臂
        la = self.parts['l_arm']; c = la.color()
        pygame.draw.rect(surface, c, (x-15, y+2, 22, 45), 2)
        pygame.draw.rect(surface, c, (x-14, y+3, 20, 43))
        label(la, x-85, y+18)

        # 右臂
        ra = self.parts['r_arm']; c = ra.color()
        pygame.draw.rect(surface, c, (x+53, y+2, 22, 45), 2)
        pygame.draw.rect(surface, c, (x+54, y+3, 20, 43))
        label(ra, x+80, y+18)
        y += 60

        # 左腿
        ll = self.parts['l_leg']; c = ll.color()
        pygame.draw.rect(surface, c, (x+10, y, 18, 50), 2)
        pygame.draw.rect(surface, c, (x+11, y+1, 16, 48))
        label(ll, x-70, y+20)

        # 右腿
        rl = self.parts['r_leg']; c = rl.color()
        pygame.draw.rect(surface, c, (x+32, y, 18, 50), 2)
        pygame.draw.rect(surface, c, (x+33, y+1, 16, 48))
        label(rl, x+55, y+20)

body = Body()

# ==================== 配方 ====================
recipes = [
    {"name":"石刀",   "icon":"🔪", "cat":"weapon", "need":{"石头":3,"木棍":2}, "desc":"基础武器 ATK+10", "atk":10},
    {"name":"长矛",   "icon":"🗡️", "cat":"weapon", "need":{"石头":5,"木棍":4,"藤蔓":2}, "desc":"中型武器 ATK+20", "atk":20},
    {"name":"弓箭",   "icon":"🏹", "cat":"weapon", "need":{"木棍":6,"藤蔓":4,"石头":3}, "desc":"远程武器 ATK+28", "atk":28},
    {"name":"骨刃",   "icon":"⚔️", "cat":"weapon", "need":{"骨头":6,"兽皮":2,"藤蔓":3}, "desc":"重型武器 ATK+35", "atk":35},
    {"name":"陷阱",   "icon":"🪤", "cat":"tool",   "need":{"木棍":6,"藤蔓":4}, "desc":"放置后自动捕猎"},
    {"name":"净水器", "icon":"💧", "cat":"tool",   "need":{"石头":8,"木棍":4,"布料":2}, "desc":"净化脏水"},
    {"name":"钓竿",   "icon":"🎣", "cat":"tool",   "need":{"木棍":3,"藤蔓":3}, "desc":"河流钓鱼"},
    {"name":"火把",   "icon":"🔦", "cat":"tool",   "need":{"木棍":2,"布料":1}, "desc":"夜间照明驱兽"},
    {"name":"绳索",   "icon":"🪢", "cat":"tool",   "need":{"藤蔓":4}, "desc":"制作材料"},
    {"name":"担架",   "icon":"🛏️", "cat":"tool",   "need":{"木棍":8,"藤蔓":4,"布料":3}, "desc":"骨折后移动辅助"},
    {"name":"绷带",   "icon":"🩹", "cat":"med",    "need":{"布料":3}, "desc":"止血+恢复10HP"},
    {"name":"夹板",   "icon":"🦴", "cat":"med",    "need":{"木棍":4,"布料":2,"藤蔓":1}, "desc":"固定骨折"},
    {"name":"草药膏", "icon":"🌿", "cat":"med",    "need":{"草药":4,"浆果":2}, "desc":"治疗感染+恢复15HP"},
    {"name":"急救包", "icon":"🏥", "cat":"med",    "need":{"布料":5,"草药":4,"净水":2}, "desc":"全面治疗+30HP"},
    {"name":"抗生素", "icon":"💊", "cat":"med",    "need":{"草药":6,"净水":2,"浆果":3}, "desc":"根治感染+疾病"},
    {"name":"营火",   "icon":"🔥", "cat":"build",  "need":{"木棍":6,"石头":4}, "desc":"取暖烹饪照明"},
    {"name":"庇护所", "icon":"🏠", "cat":"build",  "need":{"木棍":20,"石头":12,"藤蔓":8,"布料":4}, "desc":"安全休息"},
    {"name":"围墙",   "icon":"🧱", "cat":"build",  "need":{"石头":25,"木棍":15,"藤蔓":5}, "desc":"减少夜袭概率", "requires":"庇护所"},
    {"name":"烤肉",   "icon":"🥩", "cat":"food",   "need":{"生肉":1,"木棍":1}, "desc":"饱食+40 体力+15", "requires":"营火"},
    {"name":"草药茶", "icon":"🍵", "cat":"food",   "need":{"草药":2,"净水":1}, "desc":"精神+20 可治病", "requires":"营火"},
    {"name":"鱼干",   "icon":"🐟", "cat":"food",   "need":{"生鱼":2,"木棍":1}, "desc":"饱食+25", "requires":"营火"},
    {"name":"炖肉汤", "icon":"🍲", "cat":"food",   "need":{"生肉":2,"净水":1,"草药":1}, "desc":"饱食+50 HP+20", "requires":"营火"},
    {"name":"皮革甲", "icon":"🛡️", "cat":"armor",  "need":{"兽皮":4,"藤蔓":3}, "desc":"DEF+8"},
    {"name":"骨甲",   "icon":"🦺", "cat":"armor",  "need":{"兽皮":3,"骨头":5,"藤蔓":3}, "desc":"DEF+16"},
    {"name":"铁甲",   "icon":"⛓️", "cat":"armor",  "need":{"石头":10,"兽皮":4,"骨头":3,"藤蔓":4}, "desc":"DEF+25"},
]

# ==================== 野兽 ====================
beasts = [
    {"name":"野兔","icon":"🐇","hp":25, "atk":3,  "xp":10,"loot":{"生肉":1},"agg":False},
    {"name":"毒蛇","icon":"🐍","hp":35, "atk":14, "xp":25,"loot":{"生肉":1,"草药":1},"agg":True,"poison":True},
    {"name":"野狼","icon":"🐺","hp":75, "atk":20, "xp":45,"loot":{"生肉":2,"兽皮":1,"骨头":1},"agg":True},
    {"name":"野猪","icon":"🐗","hp":110,"atk":25, "xp":60,"loot":{"生肉":3,"兽皮":2,"骨头":2},"agg":True},
    {"name":"黑熊","icon":"🐻","hp":170,"atk":38, "xp":95,"loot":{"生肉":5,"兽皮":3,"骨头":3},"agg":True},
    {"name":"雪豹","icon":"🐆","hp":130,"atk":42, "xp":110,"loot":{"生肉":3,"兽皮":3},"agg":True},
    {"name":"狼群","icon":"🐺🐺","hp":200,"atk":30,"xp":130,"loot":{"生肉":5,"兽皮":3,"骨头":4},"agg":True},
]

# ==================== 探索区域 ====================
areas = [
    {"name":"森林","icon":"🌲","res":{"木棍":(1,4),"浆果":(0,3),"草药":(0,2),"藤蔓":(0,2),"蘑菇":(0,1)},
     "beasts":[0,1,2,3],"desc":"丰富的木材和浆果"},
    {"name":"河流","icon":"🏞️","res":{"净水":(1,2),"生鱼":(0,2),"石头":(1,2)},
     "beasts":[1],"desc":"水源和鱼类"},
    {"name":"山洞","icon":"🕳️","res":{"石头":(2,4),"骨头":(0,2),"布料":(0,1)},
     "beasts":[2,3,4],"desc":"石头和稀有材料"},
    {"name":"废墟","icon":"🏚️","res":{"布料":(1,3),"石头":(1,2),"木棍":(0,2),"草药":(0,1)},
     "beasts":[1,2,3],"desc":"废墟中可能有旧物资"},
    {"name":"雪山","icon":"🏔️","res":{"石头":(2,5),"骨头":(1,3),"兽皮":(0,2)},
     "beasts":[4,5,6],"desc":"极端环境，稀有资源"},
]

# ==================== 游戏主体 ====================
class Game:
    def __init__(self):
        self.state = "menu"
        self.msgs = ["🏔️ 欢迎来到硬核荒野求生 — 终极版！",
                     "⏱️ 时间流逝极慢，每现实秒≈0.5游戏分钟",
                     "💀 每一个决定都可能让你丧命！"]

        self.hunger   = 100
        self.thirst   = 100
        self.stamina  = 100
        self.temp     = 37.0
        self.sanity   = 100
        self.energy   = 100

        self.base_atk = 5
        self.base_def = 0
        self.weapon   = None
        self.armor    = None

        self.inv = {"木棍":3, "石头":2, "浆果":3}
        self.traps = 0
        self.has_campfire = False
        self.has_shelter = False
        self.has_wall = False
        self.campfire_fuel = 0

        self.poisoned = False
        self.sick = False
        self.starving = False
        self.hallucinating = False   # ★ 幻觉

        self.food_rot = {}
        self.xp = 0
        self.level = 1
        self.kills = 0
        self.explore_count = 0

        self.enemy = None
        self.battle_msg = []

        self.last_tick_hour = 6
        self.status_timer = 0
        self.night_timer = 0

        self.death_cause = ""

        # 事件冷却
        self.event_cooldown = 0

    def msg(self, m):
        self.msgs.append(m)
        if len(self.msgs) > 100:
            self.msgs.pop(0)

    def add(self, name, cnt=1):
        self.inv[name] = self.inv.get(name, 0) + cnt
        if name in ["生肉","生鱼","浆果","蘑菇"]:
            if name not in self.food_rot:
                self.food_rot[name] = 0

    def rm(self, name, cnt=1):
        if name in self.inv and self.inv[name] >= cnt:
            self.inv[name] -= cnt
            if self.inv[name] <= 0:
                del self.inv[name]
                if name in self.food_rot:
                    del self.food_rot[name]
            return True
        return False

    def has(self, needs):
        return all(self.inv.get(k,0) >= v for k,v in needs.items())

    def get_atk(self):
        b = self.base_atk
        if self.weapon:
            for r in recipes:
                if r['name'] == self.weapon:
                    b += r.get('atk', 0)
        return int(b * body.atk_mod())

    def get_def(self):
        d = self.base_def
        if self.armor:
            for r in recipes:
                if r['name'] == self.armor and r['cat'] == 'armor':
                    d += int(r['desc'].split('+')[1]) if '+' in r['desc'] else 0
        return d

    # ========= 时间推进 =========
    def tick(self):
        """每帧调用"""
        h = time_sys.get_hour()

        # 每小时触发
        if h != self.last_tick_hour:
            self.last_tick_hour = h
            self._hourly()

        # 状态效果（每180帧 ≈ 3秒现实 ≈ 1.5游戏分钟）
        self.status_timer += 1
        if self.status_timer >= 180:
            self.status_timer = 0
            self._status_tick()

        # 夜间事件（每300帧 ≈ 5秒现实）
        if time_sys.is_night():
            self.night_timer += 1
            if self.night_timer >= 300:
                self.night_timer = 0
                self._night_event()

    def _hourly(self):
        """每小时生存消耗"""
        s = time_sys.season
        w = weather.weather

        # 饥饿（冬季消耗更多）
        hunger_rate = 1.2 if s != 3 else 1.8
        self.hunger = max(0, self.hunger - hunger_rate)

        # 口渴（夏季/晴天消耗更多）
        thirst_rate = 1.5
        if s == 1: thirst_rate = 2.0
        if w == 0: thirst_rate += 0.5
        self.thirst = max(0, self.thirst - thirst_rate)

        # 体力自然恢复
        if not time_sys.is_night():
            self.stamina = min(100, self.stamina + 1.5)
            if self.has_shelter:
                self.stamina = min(100, self.stamina + 2)
        else:
            # 夜间体力缓慢下降（除非有庇护所）
            if not self.has_shelter:
                self.stamina = max(0, self.stamina - 1)

        # 精神值
        if time_sys.is_night():
            if not self.has_campfire:
                self.sanity = max(0, self.sanity - 4)  # 黑暗无火精神崩溃
            else:
                self.sanity = max(0, self.sanity - 1)
            if not self.has_shelter:
                self.sanity = max(0, self.sanity - 2)
        else:
            self.sanity = min(100, self.sanity + 0.5)
            if self.has_shelter:
                self.sanity = min(100, self.sanity + 1)

        # 幻觉
        if self.sanity < 15:
            self.hallucinating = True
        elif self.sanity > 30:
            self.hallucinating = False

        # 饥饿致死
        if self.hunger <= 0:
            self.starving = True
            part = body.random_part()
            body.parts[part].take_damage(3)
            if time_sys.get_minute() == 0:
                self.msg("⚠️ 你快饿死了！生命持续流失！")
        else:
            self.starving = False

        if self.thirst <= 0:
            self.msg("⚠️ 严重脱水！身体急剧恶化！")
            body.parts['torso'].take_damage(5)
            body.parts['head'].take_damage(3)

        # 体温
        self._update_temp()

        # 食物腐烂
        for food in list(self.food_rot.keys()):
            self.food_rot[food] += 1
            if self.food_rot[food] > 60:  # 60游戏小时后腐烂
                if food in self.inv:
                    c = self.inv[food]
                    del self.inv[food]
                    del self.food_rot[food]
                    self.msg(f"🤢 {food}腐烂了！失去{c}个！")
                    self.sanity = max(0, self.sanity - 5)

        # 营火消耗
        if self.has_campfire:
            self.campfire_fuel = max(0, self.campfire_fuel - 1)
            if self.campfire_fuel <= 0:
                self.has_campfire = False
                self.msg("🔥 营火熄灭了！需要添加木棍！")

        # 陷阱
        if self.traps > 0 and random.random() < 0.12 * self.traps:
            loot = random.choice(["生肉","兽皮","骨头"])
            self.add(loot)
            self.msg(f"🪤 陷阱捕获: {loot} x1")

        # 生病
        if not self.sick and random.random() < 0.015:
            if self.temp < 35 or self.temp > 39.5:
                self.sick = True
                self.msg("🤒 你生病了！体温异常！")

    def _update_temp(self):
        s = time_sys.season
        w = weather.weather
        target = 37.0

        if s == 3:
            target -= 3.5
            if w in [4,5]: target -= 3.5
        elif s == 2: target -= 1.5
        elif s == 1:
            target += 1.5
            if w == 0: target += 1.5

        if time_sys.is_night(): target -= 2.5
        if self.has_campfire:  target += 3.5
        if self.has_shelter:  target += 2.0
        if w in [2,3]: target -= 1.5

        self.temp += (target - self.temp) * 0.04
        self.temp = round(self.temp, 1)

        # 冻伤
        if self.temp < 34:
            for pk in ['l_arm','r_arm','l_leg','r_leg']:
                if random.random() < 0.08:
                    body.parts[pk].frostbitten = True
                    body.parts[pk].take_damage(3)
            if self.temp < 33:
                self.msg("🥶 严重低温！肢体冻伤！")

        # 中暑
        if self.temp > 40:
            self.msg("🥵 严重中暑！")
            self.thirst = max(0, self.thirst - 4)
            self.stamina = max(0, self.stamina - 8)
            body.parts['head'].take_damage(3)

    def _status_tick(self):
        if not body.tick():
            self.state = "death"
            self.death_cause = "肢体致命伤"
            return

        if self.poisoned:
            body.parts['torso'].take_damage(2)
            self.stamina = max(0, self.stamina - 4)
            if random.random() < 0.08:
                self.poisoned = False
                self.msg("💚 毒素代谢完毕！")

        # 流血警告
        bl = [k for k,v in body.parts.items() if v.bleeding]
        if bl:
            self.msg(f"🩸 流血: {', '.join(body.parts[k].name for k in bl)}")

        # 感染
        inf = [k for k,v in body.parts.items() if v.infected]
        if inf:
            self.msg(f"🦠 感染: {', '.join(body.parts[k].name for k in inf)}")

        if not body.alive():
            self.state = "death"
            self.death_cause = "肢体致命伤"

    def _night_event(self):
        if self.has_shelter and self.has_campfire:
            # 安全恢复
            for p in body.parts.values():
                if not p.disabled: p.heal(2)
            if random.random() < 0.3:
                self.msg("🏠 庇护所和营火保护了你，平安度过。")
            return

        # 夜袭概率
        wall_bonus = 0.15 if self.has_wall else 0
        ambush_chance = 0.30 - wall_bonus
        if self.has_shelter: ambush_chance *= 0.5
        if self.has_campfire: ambush_chance *= 0.6

        if random.random() < ambush_chance:
            if time_sys.season == 3:
                idx = random.choices([3,4,5,6], weights=[20,30,25,25])[0]
            else:
                idx = random.choices([1,2,3,4,6], weights=[10,25,30,20,15])[0]
            b = dict(beasts[idx])
            b['hp'] = int(b['hp'] * 1.4)
            b['atk'] = int(b['atk'] * 1.5)
            b['night'] = True
            self.msg(f"💀 夜袭！{b['icon']}{b['name']}在黑暗中偷袭了你！")
            self.start_battle(b)
        elif random.random() < 0.25:
            self.sanity = max(0, self.sanity - 8)
            self.msg("🌙 荒野夜晚令人恐惧...精神下降")

    # ========= 行动 =========
    def explore(self):
        if self.energy < 15:
            self.msg("⚡ 精力不足！先休息！")
            return
        mm = body.move_mod()
        sc = int(20 / max(0.3, mm))
        if self.stamina < sc:
            self.msg("⚡ 体力不足！")
            return

        self.stamina -= sc
        self.energy -= 15
        self.explore_count += 1
        time_sys.advance(3)  # 探索消耗3游戏分钟

        area = random.choice(areas)
        self.msg(f"🔍 前往{area['icon']} {area['name']}...")

        gm = body.gather_mod()
        for res, (lo,hi) in area['res'].items():
            amt = max(0, int(random.randint(lo, hi) * gm))
            if amt > 0:
                self.add(res, amt)
                self.msg(f"  📦 {res} x{amt}")

        # 遭遇
        encounter_chance = 0.35
        if time_sys.is_night(): encounter_chance = 0.55

        if random.random() < encounter_chance:
            if time_sys.is_night():
                pool = [b for b in area['beasts'] if b >= 2] or area['beasts']
            else:
                pool = area['beasts']
            idx = random.choice(pool)
            b = dict(beasts[idx])
            if time_sys.is_night():
                b['hp'] = int(b['hp'] * 1.3)
                b['atk'] = int(b['atk'] * 1.3)
                b['night'] = True
                self.msg(f"⚠️ 黑暗中出现了{b['icon']} {b['name']}！")
            else:
                self.msg(f"⚠️ 遭遇了{b['icon']} {b['name']}！")
            self.start_battle(b)
        elif random.random() < 0.10:
            events = [
                ("发现废弃营地！", {"布料":2,"木棍":3}),
                ("溪边发现药草！", {"草药":3}),
                ("找到动物残骸！", {"骨头":3,"兽皮":1}),
                ("发现野果丛！", {"浆果":4}),
                ("岩缝中找到物资！", {"石头":4,"布料":1}),
            ]
            desc, loot = random.choice(events)
            self.msg(f"🎁 {desc}")
            for k,v in loot.items():
                self.add(k, v); self.msg(f"  📦 {k} x{v}")
            self.xp += 10

    def start_battle(self, b):
        self.enemy = b
        self.battle_msg = [f"⚔️ 战斗！{b['icon']} {b['name']} (HP:{b['hp']} ATK:{b['atk']})"]
        self.state = "battle"

    def b_attack(self):
        if not self.enemy: return
        e = self.enemy
        atk = self.get_atk()
        dmg = random.randint(int(atk*0.8), int(atk*1.3))
        # 暴击
        crit = random.random() < 0.12
        if crit: dmg = int(dmg * 1.8)

        e['hp'] -= dmg
        if crit:
            self.battle_msg.append(f"💥 暴击！对{e['name']}造成 {dmg} 伤害！")
        else:
            self.battle_msg.append(f"⚔️ 攻击{e['name']}，造成 {dmg} 伤害！")

        if e['hp'] <= 0:
            self.battle_msg.append(f"🎉 击杀{e['name']}！")
            for k,v in e['loot'].items():
                self.add(k,v); self.battle_msg.append(f"  📦 {k} x{v}")
            self.xp += e['xp']
            self.kills += 1
            self.sanity = min(100, self.sanity + 5)
            self._levelup()
            self.enemy = None
            self.state = "main"
            return

        self._enemy_atk()

    def _enemy_atk(self):
        e = self.enemy
        dmg = random.randint(int(e['atk']*0.7), int(e['atk']*1.3))
        dmg = max(1, dmg - self.get_def())
        target = body.random_part()
        actual = body.parts[target].take_damage(dmg)
        self.battle_msg.append(f"💥 {e['name']}攻击{body.parts[target].name}，{actual}伤害！")

        if body.parts[target].bleeding:
            self.battle_msg.append(f"  🩸 {body.parts[target].name}流血！")
        if body.parts[target].broken:
            self.battle_msg.append(f"  🦴 {body.parts[target].name}骨折！")
        if body.parts[target].infected:
            self.battle_msg.append(f"  🦠 伤口感染！")

        if e.get('poison') and random.random() < 0.4:
            self.poisoned = True
            self.battle_msg.append("  ☠️ 中毒了！")

        if not body.alive():
            self.death_cause = f"被{e['name']}杀死"
            self.state = "death"
            return

        self.sanity = max(0, self.sanity - 3)

    def b_flee(self):
        if not self.enemy: return
        chance = 0.40 * body.move_mod()
        if time_sys.is_night(): chance *= 0.5
        if random.random() < chance:
            self.battle_msg.append(f"🏃 成功逃离{self.enemy['name']}！")
            self.stamina = max(0, self.stamina - 25)
            self.enemy = None
            self.state = "main"
        else:
            self.battle_msg.append("❌ 逃跑失败！")
            self._enemy_atk()

    def b_item(self):
        if self.has({"草药":2}):
            self.rm("草药", 2)
            for p in body.parts.values():
                if not p.disabled: p.heal(10)
            self.battle_msg.append("🌿 用草药恢复少量HP")
        elif self.has({"浆果":2}):
            self.rm("浆果", 2)
            self.stamina = min(100, self.stamina + 15)
            self.battle_msg.append("🫐 吃浆果恢复体力")
        else:
            self.battle_msg.append("❌ 没有可用物品！")

    def rest(self):
        if self.has_shelter:
            self.stamina = min(100, self.stamina + 45)
            self.energy = min(100, self.energy + 55)
            self.sanity = min(100, self.sanity + 15)
            for p in body.parts.values():
                if not p.disabled: p.heal(5)
            time_sys.advance(240)
            self.msg("🛏️ 在庇护所休息4小时，状态大幅恢复！")
        else:
            self.stamina = min(100, self.stamina + 15)
            self.energy = min(100, self.energy + 25)
            self.sanity = max(0, self.sanity - 5)
            time_sys.advance(120)
            self.msg("😰 野外勉强休息2小时...")
            if time_sys.is_night() and random.random() < 0.3:
                idx = random.choice([2,3])
                b = dict(beasts[idx])
                self.msg(f"⚠️ 休息时被{b['icon']}{b['name']}偷袭！")
                self.start_battle(b)
                return
        self.state = "main"

    def craft(self, idx):
        r = recipes[idx]
        if not self.has(r['need']):
            self.msg(f"❌ 材料不足: {r['name']}"); return
        if r.get('requires') == '营火' and not self.has_campfire:
            self.msg("❌ 需要营火！"); return
        if r.get('requires') == '庇护所' and not self.has_shelter:
            self.msg("❌ 需要庇护所！"); return

        for k,v in r['need'].items(): self.rm(k,v)

        cat = r['cat']
        if cat == 'weapon':
            self.weapon = r['name']
            self.msg(f"⚔️ 装备{r['icon']}{r['name']}！ATK+{r.get('atk',0)}")
        elif cat == 'armor':
            self.armor = r['name']
            self.msg(f"🛡️ 装备{r['icon']}{r['name']}！")
        elif cat == 'build':
            if r['name'] == '营火':
                self.has_campfire = True; self.campfire_fuel = 30
                self.msg("🔥 生起了营火！")
            elif r['name'] == '庇护所':
                self.has_shelter = True
                self.msg("🏠 建造了庇护所！"); self.xp += 30
            elif r['name'] == '围墙':
                self.has_wall = True
                self.msg("🧱 建造了围墙！减少夜袭！"); self.xp += 20
        elif cat == 'tool':
            if r['name'] == '陷阱':
                self.traps += 1
                self.msg(f"🪤 设置陷阱！当前: {self.traps}")
            else:
                self.add(r['name'], 1)
                self.msg(f"🔧 制作{r['icon']}{r['name']}！")
        elif cat == 'med':
            self.add(r['name'], 1)
            self.msg(f"💊 制作{r['icon']}{r['name']}！")
        elif cat == 'food':
            cnt = 2 if r['name'] == '鱼干' else 1
            self.add(r['name'], cnt)
            self.msg(f"🍽️ 制作{r['icon']}{r['name']}！")

        self.stamina = max(0, self.stamina - 5)
        self.xp += 5

    def use_med(self, name):
        if name == "绷带":
            bl = [k for k,v in body.parts.items() if v.bleeding]
            if bl:
                t = bl[0]
                body.parts[t].treat_bleed()
                body.parts[t].heal(10)
                self.rm("绷带")
                self.msg(f"🩹 包扎{body.parts[t].name}！止血！")
            else:
                self.msg("❌ 没有流血部位")
        elif name == "夹板":
            br = [k for k,v in body.parts.items() if v.broken]
            if br:
                t = br[0]
                body.parts[t].fix_bone()
                body.parts[t].heal(5)
                self.rm("夹板")
                self.msg(f"🦴 固定{body.parts[t].name}！")
            else:
                self.msg("❌ 没有骨折部位")
        elif name == "草药膏":
            inf = [k for k,v in body.parts.items() if v.infected]
            if inf:
                t = inf[0]
                body.parts[t].treat_infection()
                body.parts[t].heal(15)
                self.rm("草药膏")
                self.msg(f"🌿 治疗{body.parts[t].name}感染！")
            else:
                self.msg("❌ 没有感染部位")
        elif name == "急救包":
            self.rm("急救包")
            for p in body.parts.values():
                if not p.disabled:
                    p.heal(30); p.bleeding=False; p.broken=False; p.infected=False
            self.poisoned = False; self.sick = False
            self.msg("🏥 全面治疗！")
        elif name == "抗生素":
            self.rm("抗生素")
            for p in body.parts.values():
                if not p.disabled:
                    p.infected = False; p.heal(20)
            self.poisoned = False; self.sick = False
            self.msg("💊 抗生素治疗！根治感染和疾病！")
        elif name == "草药":
            if self.rm("草药", 2):
                for p in body.parts.values():
                    if not p.disabled: p.heal(8)
                self.msg("🌿 草药简单治疗")
            else:
                self.msg("❌ 需要2个草药")

    def eat(self, name):
        if name == "浆果":
            if self.rm("浆果"):
                self.hunger = min(100, self.hunger + 12)
                self.msg("🫐 吃了浆果 +12饱食")
                if random.random() < 0.08:
                    self.msg("🤢 浆果有问题..."); body.parts['torso'].take_damage(5)
        elif name == "烤肉":
            if self.rm("烤肉"):
                self.hunger = min(100, self.hunger + 40)
                self.stamina = min(100, self.stamina + 15)
                self.sanity = min(100, self.sanity + 5)
                self.msg("🥩 烤肉 +40饱食 +15体力")
        elif name == "鱼干":
            if self.rm("鱼干"):
                self.hunger = min(100, self.hunger + 25)
                self.msg("🐟 鱼干 +25饱食")
        elif name == "蘑菇":
            if self.rm("蘑菇"):
                self.hunger = min(100, self.hunger + 10)
                if random.random() < 0.25:
                    self.poisoned = True; self.msg("🍄 蘑菇有毒！")
                else:
                    self.msg("🍄 蘑菇 +10饱食")
        elif name == "草药茶":
            if self.rm("草药茶"):
                self.stamina = min(100, self.stamina + 30)
                self.sanity = min(100, self.sanity + 20)
                if self.sick:
                    self.sick = False; self.msg("🍵 草药茶治好了病！")
                else:
                    self.msg("🍵 草药茶 +30体力 +20精神")
        elif name == "炖肉汤":
            if self.rm("炖肉汤"):
                self.hunger = min(100, self.hunger + 50)
                for p in body.parts.values():
                    if not p.disabled: p.heal(10)
                self.msg("🍲 炖肉汤 +50饱食 +20HP")
        elif name == "净水":
            if self.rm("净水"):
                self.thirst = min(100, self.thirst + 35)
                self.msg("💧 净水 +35水分")

    def drink(self):
        if self.has({"净水":1}):
            self.eat("净水")
        elif self.has({"净水器":1}):
            self.thirst = min(100, self.thirst + 35)
            self.msg("💧 净水器净化水 +35水分")
        elif self.has_campfire:
            self.thirst = min(100, self.thirst + 30)
            self.msg("💧 煮沸水 +30水分")
            if random.random() < 0.08:
                self.msg("🤢 水没完全烧开..."); body.parts['torso'].take_damage(3)
        else:
            self.thirst = min(100, self.thirst + 20)
            self.msg("💧 喝了脏水 +20水分")
            if random.random() < 0.30:
                self.sick = True; self.msg("🤢 脏水让你生病了！")

    def fuel(self):
        if self.has_campfire and self.has({"木棍":2}):
            self.rm("木棍", 2)
            self.campfire_fuel = min(60, self.campfire_fuel + 15)
            self.msg("🔥 添加木棍！")
        elif not self.has_campfire:
            self.msg("❌ 没有营火")
        else:
            self.msg("❌ 需要木棍")

    def _levelup(self):
        need = self.level * 60
        if self.xp >= need:
            self.xp -= need; self.level += 1
            self.base_atk += 2; self.base_def += 1
            for p in body.parts.values():
                if not p.disabled:
                    p.max_hp += 5; p.hp = min(p.max_hp, p.hp + 20)
            self.msg(f"⭐ 升级！Lv.{self.level} ATK+2 DEF+1")

    def score(self):
        return time_sys.get_total_days() * 50 + self.kills * 20 + self.level * 30 + self.explore_count * 5

game = Game()

# ==================== 绘制工具 ====================
def bar(s, x, y, w, h, val, mx, color, bg=(50,50,50), label=""):
    pygame.draw.rect(s, bg, (x,y,w,h), border_radius=3)
    f = max(0, min(1, val/mx))
    c = RED if f < 0.25 else (ORANGE if f < 0.5 else color)
    pygame.draw.rect(s, c, (x,y,int(w*f),h), border_radius=3)
    pygame.draw.rect(s, WHITE, (x,y,w,h), 1, border_radius=3)
    if label:
        t = font_xs.render(f"{label}: {int(val)}/{mx}", True, WHITE)
        s.blit(t, (x+4, y+1))

def btn(s, x, y, w, h, text, color=DKGRAY, hover=False, tc=WHITE):
    c = tuple(min(255,v+40) for v in color) if hover else color
    pygame.draw.rect(s, c, (x,y,w,h), border_radius=6)
    pygame.draw.rect(s, WHITE, (x,y,w,h), 1, border_radius=6)
    t = font_md.render(text, True, tc)
    tr = t.get_rect(center=(x+w//2, y+h//2))
    s.blit(t, tr)
    return pygame.Rect(x,y,w,h)

def hov(x,y,w,h,mx,my):
    return x<=mx<=x+w and y<=my<=y+h

def draw_sky(s):
    sky = time_sys.get_sky_color()
    s.fill(sky)
    h = time_sys.get_hour()
    if 6<=h<19:
        sx = int(WIDTH*(h-6)/13)
        sy = int(80+40*math.sin(math.pi*(h-6)/13))
        pygame.draw.circle(s, YELLOW, (sx,sy), 20)
        pygame.draw.circle(s, (255,230,100), (sx,sy), 16)
    else:
        mp = ((h-19)%24)/11
        mx = int(WIDTH*mp); my = int(60+30*math.sin(math.pi*mp))
        pygame.draw.circle(s, (220,220,240), (mx,my), 15)
        pygame.draw.circle(s, (200,200,220), (mx+4,my-2), 13)
    if time_sys.is_night():
        random.seed(42)
        for _ in range(35):
            sx=random.randint(0,WIDTH); sy=random.randint(0,150)
            br=random.randint(150,255)
            tw=int(br*(0.5+0.5*math.sin(time_module.time()*2+sx)))
            pygame.draw.circle(s,(tw,tw,tw),(sx,sy),1)
        random.seed()
    gc = (60,90,40) if not time_sys.is_night() else (20,35,15)
    if time_sys.season == 3:
        gc = (200,210,220) if not time_sys.is_night() else (80,85,90)
    pygame.draw.rect(s, gc, (0,180,WIDTH,HEIGHT-180))

def draw_dark(s):
    d = time_sys.get_darkness()
    if d > 0:
        ov = pygame.Surface((WIDTH,HEIGHT), pygame.SRCALPHA)
        ov.fill((0,0,20,int(255*d)))
        s.blit(ov, (0,0))
    # 幻觉效果
    if game.hallucinating:
        ov = pygame.Surface((WIDTH,HEIGHT), pygame.SRCALPHA)
        flicker = int(30 * math.sin(time_module.time() * 5))
        ov.fill((100, 0, 80, max(0, flicker)))
        s.blit(ov, (0,0))

# ==================== 界面 ====================
def draw_menu():
    draw_sky(screen)
    t = font_xl.render("🏔️ 硬核荒野求生", True, WHITE)
    screen.blit(t, t.get_rect(center=(WIDTH//2, 180)))
    sub = font_lg.render("— 终 极 硬 核 版 —", True, GOLD)
    screen.blit(sub, sub.get_rect(center=(WIDTH//2, 240)))

    features = [
        "⏱️ 超慢时间 · 1现实秒 ≈ 0.5游戏分钟 · 沉浸体验",
        "🦴 6部位肢体 · 流血/骨折/感染/冻伤/残废",
        "🌗 昼夜交替 · 夜间野兽强化 · 致命偷袭",
        "🧠 精神值 · 幻觉 · 黑暗崩溃",
        "🤒 疾病/中毒/营养不良 · 食物腐烂",
        "🌡️ 体温/冻伤/中暑 · 极端天气致命",
        "💀 永久残废 · 感染扩散 · 死亡不可逆",
    ]
    for i,f in enumerate(features):
        ft = font_md.render(f, True, (200,200,200))
        screen.blit(ft, ft.get_rect(center=(WIDTH//2, 300+i*32)))

    mx,my = pygame.mouse.get_pos()
    r = btn(screen, WIDTH//2-130, 560, 260, 55, "🎮 开始求生", DKGREEN, hov(WIDTH//2-130,560,260,55,mx,my))
    return [("start", r)]

def draw_main():
    draw_sky(screen)

    # 顶部栏
    ib = pygame.Surface((WIDTH,50), pygame.SRCALPHA)
    ib.fill((0,0,0,160)); screen.blit(ib, (0,0))

    ts = f"第{time_sys.day}天 {time_sys.get_season_name()} {time_sys.get_time_str()}"
    dn = "🌙夜" if time_sys.is_night() else ("🌅昏" if time_sys.is_dusk() else ("🌄晨" if time_sys.is_dawn() else "☀️日"))
    screen.blit(font_md.render(f"{ts} {dn}", True, WHITE), (10,12))
    screen.blit(font_md.render(weather.get_name(), True, CYAN), (350,12))
    screen.blit(font_md.render(f"⭐Lv.{game.level} XP:{game.xp}/{game.level*60}", True, GOLD), (500,12))

    bt = ""
    if game.has_campfire: bt += f"🔥({game.campfire_fuel}) "
    if game.has_shelter:  bt += "🏠 "
    if game.has_wall:     bt += "🧱 "
    if game.traps > 0:    bt += f"🪤x{game.traps} "
    if bt:
        screen.blit(font_md.render(bt, True, ORANGE), (700,12))

    # 属性条
    by = 58; bw = 200; gap = 24
    bar(screen, 10, by, bw, 19, game.hunger, 100, GREEN, label="🍖饱食")
    bar(screen, 10, by+gap, bw, 19, game.thirst, 100, BLUE, label="💧水分")
    bar(screen, 10, by+gap*2, bw, 19, game.stamina, 100, YELLOW, label="⚡体力")
    bar(screen, 10, by+gap*3, bw, 19, game.energy, 100, CYAN, label="🔋精力")
    bar(screen, 10, by+gap*4, bw, 19, game.sanity, 100, PURPLE, label="🧠精神")

    tc = GREEN if 35.5<=game.temp<=38.5 else (ORANGE if 34<=game.temp<=40 else RED)
    screen.blit(font_md.render(f"🌡️ {game.temp}°C", True, tc), (10, by+gap*5+5))

    # 状态效果
    ex = 230
    effs = []
    if game.poisoned:      effs.append(("☠️中毒", RED))
    if game.sick:          effs.append(("🤒生病", ORANGE))
    if game.starving:      effs.append(("💀饥饿", RED))
    if game.hallucinating: effs.append(("👻幻觉", PURPLE))
    bl = [k for k,v in body.parts.items() if v.bleeding]
    if bl: effs.append((f"🩸流血x{len(bl)}", RED))
    br = [k for k,v in body.parts.items() if v.broken]
    if br: effs.append((f"🦴骨折x{len(br)}", ORANGE))
    inf = [k for k,v in body.parts.items() if v.infected]
    if inf: effs.append((f"🦠感染x{len(inf)}", (200,50,200)))
    frost = [k for k,v in body.parts.items() if v.frostbitten]
    if frost: effs.append((f"🥶冻伤x{len(frost)}", CYAN))

    for i,(e,c) in enumerate(effs):
        screen.blit(font_sm.render(e, True, c), (ex + i*100, by+5))

    # 肢体
    body.draw(screen, WIDTH-200, 55)

    # 装备
    ey = 250
    ep = pygame.Surface((230,55), pygame.SRCALPHA); ep.fill((0,0,0,120))
    screen.blit(ep, (WIDTH-240, ey))
    screen.blit(font_sm.render(f"⚔️ {game.weapon or '无'} ATK:{game.get_atk()}", True, WHITE), (WIDTH-235, ey+5))
    screen.blit(font_sm.render(f"🛡️ {game.armor or '无'} DEF:{game.get_def()}", True, WHITE), (WIDTH-235, ey+25))

    # 按钮
    bny = 320; bnw = 130; bnh = 40; bng = 8
    mx,my = pygame.mouse.get_pos()
    buttons = []
    acts = [
        ("1.探索", DKGREEN, "explore"),
        ("2.喝水", BLUE, "drink"),
        ("3.进食", (150,100,50), "eat_menu"),
        ("4.制作", (100,80,150), "craft"),
        ("5.背包", (80,80,80), "inventory"),
        ("6.治疗", (150,50,50), "heal_menu"),
        ("7.休息", (60,60,100), "rest"),
        ("8.加柴", (150,100,30), "fuel"),
    ]
    for i,(text,color,action) in enumerate(acts):
        col = i % 4; row = i // 4
        bx = 12 + col*(bnw+bng)
        by2 = bny + row*(bnh+bng)
        h2 = hov(bx,by2,bnw,bnh,mx,my)
        r = btn(screen, bx, by2, bnw, bnh, text, color, h2)
        buttons.append((action, r))

    # 日志
    ly = 430; lh = HEIGHT-ly-10
    lp = pygame.Surface((WIDTH-20, lh), pygame.SRCALPHA); lp.fill((0,0,0,160))
    screen.blit(lp, (10, ly))

    vis = game.msgs[-14:]
    for i,m in enumerate(vis):
        c = WHITE
        if "⚠️" in m or "💀" in m or "❌" in m or "🩸" in m or "🦠" in m: c = RED
        elif "🎉" in m or "⭐" in m or "🎁" in m: c = GOLD
        elif "📦" in m: c = GREEN
        elif "🤢" in m or "☠️" in m: c = ORANGE
        screen.blit(font_sm.render(m, True, c), (20, ly+6+i*19))

    draw_dark(screen)
    return buttons

def draw_battle():
    draw_sky(screen)
    draw_dark(screen)
    e = game.enemy
    if not e: return []

    t = font_lg.render(f"⚔️ 战斗 - {e['icon']} {e['name']}", True, RED)
    screen.blit(t, t.get_rect(center=(WIDTH//2, 35)))

    # 敌人HP
    max_hp = e.get('orig_hp', e['hp'])
    bar(screen, WIDTH//2-160, 70, 320, 24, max(0,e['hp']), max_hp, RED, label=f"{e['name']} HP")

    # 敌人图标
    it = font_xl.render(e['icon'], True, WHITE)
    screen.blit(it, it.get_rect(center=(WIDTH//2, 140)))

    # 夜间标记
    if e.get('night'):
        nt = font_sm.render("🌙 夜间强化", True, PURPLE)
        screen.blit(nt, (WIDTH//2+60, 120))

    # 玩家状态
    by = 190
    bar(screen, 10, by, 200, 17, game.hunger, 100, GREEN, label="饱食")
    bar(screen, 10, by+20, 200, 17, game.thirst, 100, BLUE, label="水分")
    bar(screen, 10, by+40, 200, 17, game.stamina, 100, YELLOW, label="体力")

    body.draw(screen, WIDTH-200, 190)

    # 战斗日志
    ly = 360; lp = pygame.Surface((WIDTH-20,190), pygame.SRCALPHA); lp.fill((0,0,0,180))
    screen.blit(lp, (10,ly))
    for i,m in enumerate(game.battle_msg[-9:]):
        c = WHITE
        if "💥" in m or "🩸" in m or "🦴" in m or "☠️" in m: c = RED
        elif "🎉" in m or "📦" in m: c = GOLD
        screen.blit(font_sm.render(m, True, c), (20, ly+6+i*19))

    mx,my = pygame.mouse.get_pos()
    bny = 570; buttons = []
    r1 = btn(screen, 50, bny, 180, 50, "⚔️ 攻击", DKRED, hov(50,bny,180,50,mx,my))
    r2 = btn(screen, 260, bny, 180, 50, "🏃 逃跑", GRAY, hov(260,bny,180,50,mx,my))
    r3 = btn(screen, 470, bny, 180, 50, "💊 用药", (100,50,50), hov(470,bny,180,50,mx,my))
    buttons = [("attack",r1),("flee",r2),("battle_item",r3)]
    return buttons

def draw_craft():
    screen.fill((30,30,40))
    screen.blit(font_lg.render("🔧 制作", True, WHITE), (20,12))

    mx,my = pygame.mouse.get_pos()
    buttons = []
    for i,r in enumerate(recipes):
        row = i//3; col = i%3
        x = 12+col*375; y = 55+row*72
        can = game.has(r['need'])
        if r.get('requires')=='营火' and not game.has_campfire: can = False
        if r.get('requires')=='庇护所' and not game.has_shelter: can = False
        bg = DKGREEN if can else DKGRAY
        h2 = hov(x,y,360,65,mx,my)
        rect = btn(screen, x,y,360,65,"",bg,h2)
        screen.blit(font_md.render(f"{r['icon']} {r['name']}", True, WHITE if can else GRAY), (x+8,y+4))
        screen.blit(font_sm.render(r['desc'], True, (180,180,180)), (x+8,y+26))
        ns = " ".join(f"{k}x{v}" for k,v in r['need'].items())
        screen.blit(font_sm.render(ns, True, GREEN if can else RED), (x+8,y+44))
        buttons.append((("craft",i), rect))

    r = btn(screen, WIDTH-120,12,100,35,"← 返回",GRAY,hov(WIDTH-120,12,100,35,mx,my))
    buttons.append(("back",r))
    return buttons

def draw_inv():
    screen.fill((30,30,40))
    screen.blit(font_lg.render("🎒 背包", True, WHITE), (20,12))

    mx,my = pygame.mouse.get_pos()
    buttons = []
    items = list(game.inv.items())
    for i,(name,cnt) in enumerate(items):
        row=i//5; col=i%5
        x=12+col*220; y=55+row*52
        is_food = name in ["浆果","烤肉","鱼干","蘑菇","草药茶","炖肉汤"]
        is_med = name in ["绷带","夹板","草药膏","急救包","草药","抗生素"]
        bg = (80,60,40) if is_food else ((100,40,40) if is_med else (60,60,80))
        h2 = hov(x,y,210,45,mx,my)
        rect = btn(screen, x,y,210,45,f"{name} x{cnt}",bg,h2)
        if is_food: buttons.append((("eat",name),rect))
        elif is_med: buttons.append((("use_med",name),rect))

    ey = 55 + ((len(items)//5)+1)*52 + 15
    screen.blit(font_md.render(f"⚔️ {game.weapon or '无'} | 🛡️ {game.armor or '无'}", True, WHITE), (20,ey))

    r = btn(screen, WIDTH-120,12,100,35,"← 返回",GRAY,hov(WIDTH-120,12,100,35,mx,my))
    buttons.append(("back",r))
    return buttons

def draw_eat():
    screen.fill((30,30,40))
    screen.blit(font_lg.render("🍽️ 进食 / 饮水", True, WHITE), (20,12))

    mx,my = pygame.mouse.get_pos()
    buttons = []
    foods = [
        ("浆果","饱食+12，8%不适"),
        ("烤肉","饱食+40 体力+15"),
        ("鱼干","饱食+25"),
        ("蘑菇","饱食+10，25%中毒"),
        ("草药茶","体力+30 精神+20"),
        ("炖肉汤","饱食+50 HP+20"),
    ]
    for i,(name,desc) in enumerate(foods):
        x=25+(i%3)*360; y=65+(i//3)*68
        cnt = game.inv.get(name, 0)
        can = cnt > 0
        bg = (100,70,40) if can else DKGRAY
        h2 = hov(x,y,340,58,mx,my) and can
        rect = btn(screen, x,y,340,58,f"{name} x{cnt}",bg,h2)
        screen.blit(font_sm.render(desc, True, (180,180,180)), (x+8,y+35))
        if can: buttons.append((("eat",name),rect))

    y = 65 + 2*68 + 10
    rect = btn(screen, 25,y,340,50,"💧 喝水",BLUE,hov(25,y,340,50,mx,my))
    buttons.append(("drink",rect))

    r = btn(screen, WIDTH-120,12,100,35,"← 返回",GRAY,hov(WIDTH-120,12,100,35,mx,my))
    buttons.append(("back",r))
    return buttons

def draw_heal():
    screen.fill((30,30,40))
    screen.blit(font_lg.render("💊 治疗", True, WHITE), (20,12))
    body.draw(screen, 30, 55)

    mx,my = pygame.mouse.get_pos()
    buttons = []
    meds = [
        ("绷带","止血 + 10HP"),
        ("夹板","固定骨折 + 5HP"),
        ("草药膏","治感染 + 15HP"),
        ("急救包","全面治疗 + 30HP"),
        ("抗生素","根治感染+疾病 + 20HP"),
        ("草药","需2个，恢复8HP"),
    ]
    for i,(name,desc) in enumerate(meds):
        x=250; y=65+i*58
        cnt = game.inv.get(name,0)
        need = 2 if name=="草药" else 1
        can = cnt >= need
        bg = (100,40,40) if can else DKGRAY
        h2 = hov(x,y,350,50,mx,my) and can
        rect = btn(screen, x,y,350,50,f"{name} x{cnt}",bg,h2)
        screen.blit(font_sm.render(desc, True, (180,180,180)), (x+8,y+28))
        if can: buttons.append((("use_med",name),rect))

    r = btn(screen, WIDTH-120,12,100,35,"← 返回",GRAY,hov(WIDTH-120,12,100,35,mx,my))
    buttons.append(("back",r))
    return buttons

def draw_death():
    screen.fill((20,10,10))
    t = font_xl.render("💀 你死了", True, RED)
    screen.blit(t, t.get_rect(center=(WIDTH//2,130)))

    cause = game.death_cause or "未知原因"
    if game.thirst <= 0: cause = "严重脱水"
    elif game.hunger <= 0: cause = "活活饿死"
    elif game.temp < 33: cause = "冻死"
    elif game.sanity <= 0: cause = "精神崩溃"

    screen.blit(font_lg.render(f"死因: {cause}", True, (180,100,100)),
                font_lg.render(f"死因: {cause}", True, (180,100,100)).get_rect(center=(WIDTH//2,200)))

    stats = [
        f"📅 存活: {time_sys.get_total_days()}天",
        f"⭐ 等级: {game.level}",
        f"⚔️ 击杀: {game.kills}",
        f"🔍 探索: {game.explore_count}",
        f"🏆 评分: {game.score()}",
    ]
    for i,s in enumerate(stats):
        st = font_md.render(s, True, WHITE)
        screen.blit(st, st.get_rect(center=(WIDTH//2, 270+i*35)))

    mx,my = pygame.mouse.get_pos()
    r = btn(screen, WIDTH//2-110, 500, 220, 50, "🔄 重新开始", DKGREEN, hov(WIDTH//2-110,500,220,50,mx,my))
    return [("restart",r)]

# ==================== 主循环 ====================
running = True
buttons = []

while running:
    for ev in pygame.event.get():
        if ev.type == pygame.QUIT:
            running = False

        elif ev.type == pygame.KEYDOWN:
            if game.state == "battle":
                if ev.key in [pygame.K_1, pygame.K_a]: game.b_attack()
                elif ev.key in [pygame.K_2, pygame.K_f]: game.b_flee()
                elif ev.key in [pygame.K_3, pygame.K_h]: game.b_item()
            elif game.state == "main":
                if ev.key == pygame.K_1: game.explore()
                elif ev.key == pygame.K_2: game.drink()
                elif ev.key == pygame.K_3: game.state = "eat_menu"
                elif ev.key == pygame.K_4: game.state = "craft"
                elif ev.key == pygame.K_5: game.state = "inventory"
                elif ev.key == pygame.K_6: game.state = "heal_menu"
                elif ev.key == pygame.K_7: game.rest()
                elif ev.key == pygame.K_8: game.fuel()
            if ev.key == pygame.K_ESCAPE:
                if game.state not in ["menu","death"]:
                    game.state = "main"

        elif ev.type == pygame.MOUSEBUTTONDOWN and ev.button == 1:
            for action, rect in buttons:
                if rect.collidepoint(ev.pos):
                    if action == "start" or action == "restart":
                        game = Game(); game.state = "main"
                        time_sys.__init__(); weather.__init__(); body.__init__()
                    elif action == "explore": game.explore()
                    elif action == "drink": game.drink()
                    elif action == "eat_menu": game.state = "eat_menu"
                    elif action == "craft": game.state = "craft"
                    elif action == "inventory": game.state = "inventory"
                    elif action == "heal_menu": game.state = "heal_menu"
                    elif action == "rest": game.rest()
                    elif action == "fuel": game.fuel()
                    elif action == "back": game.state = "main"
                    elif action == "attack": game.b_attack()
                    elif action == "flee": game.b_flee()
                    elif action == "battle_item": game.b_item()
                    elif isinstance(action, tuple):
                        if action[0] == "craft": game.craft(action[1])
                        elif action[0] == "eat": game.eat(action[1])
                        elif action[0] == "use_med": game.use_med(action[1])
                    break

    # 更新
    time_sys.update()
    weather.update(time_sys.season)
    if game.state not in ["menu","death"]:
        game.tick()
        if not body.alive():
            game.state = "death"
            if not game.death_cause: game.death_cause = "肢体致命伤"

    # 绘制
    if game.state == "menu":       buttons = draw_menu()
    elif game.state == "main":     buttons = draw_main()
    elif game.state == "battle":   buttons = draw_battle()
    elif game.state == "craft":    buttons = draw_craft()
    elif game.state == "inventory":buttons = draw_inv()
    elif game.state == "eat_menu": buttons = draw_eat()
    elif game.state == "heal_menu":buttons = draw_heal()
    elif game.state == "death":    buttons = draw_death()

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()