namespace LivingVillage.Kernel

module Sim =

    [<Struct>]
    type Vec2 =
        { X: float32
          Y: float32 }

    [<Struct>]
    type Avatar =
        { Pos: Vec2 }

    type Input =
        { MoveX: float32
          MoveY: float32 }

    type TimeStep =
        { Input: Input }

    [<Struct>]
    type NoHost =
        { Reserved: uint64 }

    [<Struct>]
    type NpcId =
        | NpcId of int

    [<Struct>]
    type Needs =
        { Hunger: float32
          Energy: float32
          Social: float32
          Money: float32 }

    [<Struct>]
    type Personality =
        { Drive: float32
          Aggression: float32
          Extraversion: float32
          Honesty: float32
          Greed: float32 }

    type ItemKind =
        | Food

    type NpcActionKind =
        | Eat
        | Sleep
        | Wander
        | Work
        | Chat

    [<Struct>]
    type RumorId =
        | RumorId of int64

    type MemoryKind =
        | Meal
        | Rest
        | Pay
        | Hungry
        | Chatted of NpcId
        | Rumor of RumorId
        | Bought of NpcId * ItemKind * int * float32
        | Sold of NpcId * ItemKind * int * float32

    type RumorEvent =
        { Id: RumorId
          Tick: int64
          OriginTick: int64
          Source: NpcId
          Narrator: NpcId
          Receiver: NpcId
          Parent: RumorId option
          Depth: int
          Strength: float32 }

    type MemoryEvent =
        { Tick: int64
          Kind: MemoryKind
          Valence: float32 }

    type InteractionKind =
        | ChatInit of NpcId * NpcId
        | TradeEvent of NpcId * NpcId * ItemKind * int * float32

    type InteractionEvent =
        { Tick: int64
          Kind: InteractionKind }

    [<Struct>]
    type Mind =
        { Needs: Needs
          Personality: Personality
          Action: NpcActionKind
          Target: Vec2
          ActionAge: int64
          EffectDone: bool
          HungerFlagged: bool
          Memory: MemoryEvent list }

    [<Struct>]
    type Npc =
        { Id: NpcId
          Pos: Vec2
          Inventory: Map<ItemKind, int>
          Mind: Mind }

    [<Struct>]
    type World =
        { Tick: int64
          Time: float
          Rng: RngState
          Avatar: Avatar
          NoHost: NoHost
          Npcs: Npc[]
          Events: InteractionEvent list
          Rumors: RumorEvent list }

    type ChatRequest =
        { Narrator: NpcId
          Receiver: NpcId }

    type ChatFailure =
        | NarratorNotFound
        | ReceiverNotFound
        | ChatSameParticipant
        | ParticipantNotChatable

    type ChatResult =
        | ChatSucceeded of RumorEvent option * World
        | ChatRejected of ChatFailure * World

    type TradeRequest =
        { Buyer: NpcId
          Seller: NpcId
          Item: ItemKind
          Quantity: int }

    type TradeFailure =
        | BuyerNotFound
        | SellerNotFound
        | SameParticipant
        | InvalidQuantity
        | OutOfStock
        | InsufficientFunds

    type TradeResult =
        | TradeSucceeded of World
        | TradeRejected of TradeFailure * World

    let ticksPerSecond = 60L
    let secondsPerDay = 86400L
    let ticksPerDay = secondsPerDay * ticksPerSecond
    let dtSeconds = 1.0 / float ticksPerSecond
    let dtSecondsF = 1.0f / float32 ticksPerSecond

    let mapWidthTiles = 64
    let mapHeightTiles = 48
    let tilePixels = 32
    let avatarSpeed = 160.0f

    let npcSpeed = 80.0f
    let arriveEpsilon = 2.0f

    let memoryCapacity = 64
    let minActionTicks = 600L
    let urgentThreshold = 20.0f
    let nightSleepMultiplier = 3.0f
    let npcCount = 30
    let chatRangePx = 96.0f
    let chatRangeSq = chatRangePx * chatRangePx
    let chatTicks = 300L
    let chatSocialRestore = 40.0f
    let chatValence = 0.3f
    let rumorFreshnessTicks = 3L * ticksPerDay
    let rumorHalfLifeTicks = ticksPerDay
    let rumorMinimumStrength = 0.125f

    // 关系网派生（纯函数；仅在 dump/视图打开时调用，不进 step 热路径）
    let relationHalfLifeTicks = ticksPerDay // HALF_LIFE = 1 模拟日（修复单位错误：原 86400L 实为 24 模拟分钟；1 模拟日 = ticksPerDay = 5,184,000 tick）
    let relationThreshold = 0.5f // |rel| > 0.5 视为有关系

    let clamp (v: float32) (lo: float32) (hi: float32) : float32 = if v < lo then lo elif v > hi then hi else v

    let hungerDecayPerTick = 0.0012f
    let energyDecayPerTick = 0.0010f
    let socialDecayPerTick = 0.0008f
    let moneyDecayPerTick = 0.0006f

    let private tileCenter (tx: int) (ty: int) : Vec2 =
        { X = float32 (tx * tilePixels + tilePixels / 2)
          Y = float32 (ty * tilePixels + tilePixels / 2) }

    let kitchenPoint = tileCenter 10 10
    let homePoint = tileCenter 52 10
    let plazaPoint = tileCenter 32 24
    let worksitePoint = tileCenter 52 38

    let actionTarget (kind: NpcActionKind) : Vec2 =
        match kind with
        | Eat -> kitchenPoint
        | Sleep -> homePoint
        | Wander -> plazaPoint
        | Work -> worksitePoint
        | Chat -> plazaPoint

    let isNightTick (tick: int64) : bool =
        let hourTicks = ticksPerDay / 24L
        let tod = tick % ticksPerDay
        tod >= 22L * hourTicks || tod < 6L * hourTicks

    let valenceOfKind (kind: MemoryKind) : float32 =
        match kind with
        | Meal -> 0.5f
        | Rest -> 0.4f
        | Pay -> 0.2f
        | Hungry -> -0.4f
        | Chatted _ -> chatValence
        | Rumor _ -> 0.1f
        | Bought _ -> 0.3f
        | Sold _ -> 0.3f

    let recordMemory (tick: int64) (kind: MemoryKind) (mem: MemoryEvent list) : MemoryEvent list =
        let updated = { Tick = tick; Kind = kind; Valence = valenceOfKind kind } :: mem
        let isRelational (event: MemoryEvent) =
            match event.Kind with
            | Chatted _ -> true
            | _ -> false
        let relationalCount = updated |> List.sumBy (fun event -> if isRelational event then 1 else 0)
        let relationalCapacity = min memoryCapacity relationalCount
        let routineCapacity = memoryCapacity - relationalCapacity
        let rec retain relationalLeft routineLeft remaining kept =
            match remaining with
            | [] -> List.rev kept
            | event :: tail when isRelational event && relationalLeft > 0 ->
                retain (relationalLeft - 1) routineLeft tail (event :: kept)
            | event :: tail when not (isRelational event) && routineLeft > 0 ->
                retain relationalLeft (routineLeft - 1) tail (event :: kept)
            | _ :: tail -> retain relationalLeft routineLeft tail kept
        // Relation weights are derived from this snapshot, so interaction memories must outlive routine churn.
        retain relationalCapacity routineCapacity updated []

    let actionMemoryKind (kind: NpcActionKind) : MemoryKind option =
        match kind with
        | Eat -> Some Meal
        | Sleep -> Some Rest
        | Work -> Some Pay
        | Wander -> None
        | Chat -> None

    let personalityOfSeed (seed: uint64) : Personality =
        let a, r1 = Rng.nextFloat32 (Rng.ofSeed seed)
        let b, r2 = Rng.nextFloat32 r1
        let c, r3 = Rng.nextFloat32 r2
        let d, r4 = Rng.nextFloat32 r3
        let e, _ = Rng.nextFloat32 r4
        { Drive = a
          Aggression = b
          Extraversion = c
          Honesty = d
          Greed = e }

    let needsClamp (n: Needs) : Needs =
        { Hunger = clamp n.Hunger 0.0f 100.0f
          Energy = clamp n.Energy 0.0f 100.0f
          Social = clamp n.Social 0.0f 100.0f
          Money = clamp n.Money 0.0f 100.0f }

    let scoreAction (night: bool) (needs: Needs) (p: Personality) (kind: NpcActionKind) : float32 =
        let raw =
            match kind with
            | Eat -> (100.0f - needs.Hunger) * (0.25f + 2.0f * p.Drive)
            | Sleep -> (100.0f - needs.Energy) * (0.25f + 2.0f * (1.0f - p.Drive))
            | Wander -> (100.0f - needs.Social) * (0.25f + 2.0f * p.Extraversion)
            | Work -> (100.0f - needs.Money) * (0.25f + 2.0f * p.Greed)
            | Chat -> 0.0f
        if kind = Sleep && night then raw * nightSleepMultiplier else raw

    let decideAction (night: bool) (needs: Needs) (p: Personality) : NpcActionKind =
        let candidates = [ Eat; Sleep; Wander; Work ]
        candidates |> List.maxBy (scoreAction night needs p)

    let needsUrgent (n: Needs) : bool =
        n.Hunger < urgentThreshold
        || n.Energy < urgentThreshold
        || n.Social < urgentThreshold
        || n.Money < urgentThreshold

    let applyActionEffect (kind: NpcActionKind) (n: Needs) : Needs =
        match kind with
        | Eat -> { n with Hunger = n.Hunger + 40.0f; Money = n.Money - 5.0f }
        | Sleep -> { n with Energy = n.Energy + 60.0f }
        | Wander -> { n with Social = n.Social + 15.0f; Hunger = n.Hunger - 2.0f }
        | Work -> { n with Money = n.Money + 20.0f; Energy = n.Energy - 10.0f }
        | Chat -> { n with Social = n.Social + chatSocialRestore }
        |> needsClamp

    let private moveToward (pos: Vec2) (target: Vec2) (maxStep: float32) : struct (Vec2 * bool) =
        let dx = target.X - pos.X
        let dy = target.Y - pos.Y
        let len = sqrt (dx * dx + dy * dy)
        if len <= maxStep + arriveEpsilon then struct (target, true)
        else
            let inv = maxStep / len
            struct ({ X = pos.X + dx * inv; Y = pos.Y + dy * inv }, false)

    let initialWorld (seed: uint64) : World =
        let centerX = float32 (mapWidthTiles * tilePixels / 2 - tilePixels / 2)
        let centerY = float32 (mapHeightTiles * tilePixels / 2 - tilePixels / 2)
        let personality = personalityOfSeed seed
        let needs = { Hunger = 100.0f; Energy = 100.0f; Social = 100.0f; Money = 50.0f }
        let inventory = Map.ofList [ Food, 10 ]
        let startAction = decideAction (isNightTick 0L) needs personality
        let npc =
            { Id = NpcId 0
              Pos = { X = centerX; Y = centerY }
              Inventory = inventory
              Mind =
                { Needs = needs
                  Personality = personality
                  Action = startAction
                  Target = actionTarget startAction
                  ActionAge = 0L
                  EffectDone = false
                  HungerFlagged = false
                  Memory = [] } }
        { Tick = 0L
          Time = 0.0
          Rng = Rng.ofSeed seed
          Avatar = { Pos = { X = centerX; Y = centerY } }
          NoHost = { Reserved = 0UL }
          Npcs = [| npc |]
          Events = []
          Rumors = [] }

    let initialWorldN (seed: uint64) (count: int) : World =
        let base_ = initialWorld seed
        let cols = 6
        let spacing = 64.0f
        let needs = { Hunger = 100.0f; Energy = 100.0f; Social = 100.0f; Money = 50.0f }
        let inventory = Map.ofList [ Food, 10 ]
        let npcs =
            Array.init count (fun i ->
                let col = i % cols
                let row = i / cols
                let pos =
                    { X = plazaPoint.X + (float32 col - 2.5f) * spacing
                      Y = plazaPoint.Y + (float32 row - 2.0f) * spacing }
                let personality = personalityOfSeed (seed + uint64 i * 0x9E3779B97F4A7C15UL)
                let startAction = decideAction (isNightTick 0L) needs personality
                { Id = NpcId i
                  Pos = pos
                  Inventory = inventory
                  Mind =
                    { Needs = needs
                      Personality = personality
                      Action = startAction
                      Target = actionTarget startAction
                      ActionAge = 0L
                      EffectDone = false
                      HungerFlagged = false
                      Memory = [] } })
        { base_ with Npcs = npcs }

    let private inventoryQuantity (item: ItemKind) (inventory: Map<ItemKind, int>) : int =
        inventory |> Map.tryFind item |> Option.defaultValue 0

    let private changeInventory (item: ItemKind) (delta: int) (inventory: Map<ItemKind, int>) : Map<ItemKind, int> =
        let next = inventoryQuantity item inventory + delta
        if next <= 0 then Map.remove item inventory else Map.add item next inventory

    let private findNpcIndex (id: NpcId) (npcs: Npc[]) : int option =
        npcs |> Array.tryFindIndex (fun npc -> npc.Id = id)

    let private recentTransactionPrice (item: ItemKind) (world: World) : float32 option =
        world.Npcs
        |> Array.toList
        |> List.collect (fun npc -> npc.Mind.Memory)
        |> List.choose (fun event ->
            match event.Kind with
            | Bought (_, tradedItem, _, price) when tradedItem = item -> Some(event.Tick, price)
            | Sold (_, tradedItem, _, price) when tradedItem = item -> Some(event.Tick, price)
            | _ -> None)
        |> List.sortByDescending fst
        |> List.truncate 8
        |> List.map snd
        |> function
            | [] -> None
            | prices -> Some(List.average prices)

    let quotePrice (request: TradeRequest) (world: World) : float32 option =
        match findNpcIndex request.Buyer world.Npcs, findNpcIndex request.Seller world.Npcs with
        | Some buyerIndex, Some sellerIndex when buyerIndex <> sellerIndex ->
            let buyer = world.Npcs.[buyerIndex]
            let seller = world.Npcs.[sellerIndex]
            let basePrice =
                match request.Item with
                | Food -> 10.0f
            let buyerUrgency = clamp ((100.0f - buyer.Mind.Needs.Hunger) / 100.0f) 0.0f 1.0f
            let stockPressure =
                1.0f - clamp (float32 (inventoryQuantity request.Item seller.Inventory) / 20.0f) 0.0f 1.0f
            let sellerNeed = clamp ((100.0f - seller.Mind.Needs.Money) / 100.0f) 0.0f 1.0f
            let personalityFactor =
                0.2f * seller.Mind.Personality.Greed
                + 0.1f * (1.0f - buyer.Mind.Personality.Honesty)
                - 0.05f * buyer.Mind.Personality.Greed
            let marketFactor =
                match recentTransactionPrice request.Item world with
                | Some recent -> clamp (0.85f + 0.15f * recent / basePrice) 0.75f 1.5f
                | None -> 1.0f
            let raw =
                basePrice
                * (0.75f
                   + 0.35f * buyerUrgency
                   + 0.30f * stockPressure
                   + 0.15f * sellerNeed
                   + personalityFactor)
                * marketFactor
            Some(clamp raw 0.01f 1000.0f)
        | _ -> None

    let trade (request: TradeRequest) (world: World) : TradeResult =
        match findNpcIndex request.Buyer world.Npcs with
        | None -> TradeRejected(BuyerNotFound, world)
        | Some buyerIndex ->
            match findNpcIndex request.Seller world.Npcs with
            | None -> TradeRejected(SellerNotFound, world)
            | Some sellerIndex when buyerIndex = sellerIndex -> TradeRejected(SameParticipant, world)
            | Some sellerIndex when request.Quantity <= 0 -> TradeRejected(InvalidQuantity, world)
            | Some sellerIndex ->
                let buyer = world.Npcs.[buyerIndex]
                let seller = world.Npcs.[sellerIndex]
                let stock = inventoryQuantity request.Item seller.Inventory
                if stock < request.Quantity then
                    TradeRejected(OutOfStock, world)
                else
                    match quotePrice request world with
                    | None -> TradeRejected(SameParticipant, world)
                    | Some unitPrice ->
                        let total = unitPrice * float32 request.Quantity
                        if buyer.Mind.Needs.Money < total then
                            TradeRejected(InsufficientFunds, world)
                        else
                            let newNpcs = Array.copy world.Npcs
                            let buyerMemory =
                                recordMemory world.Tick (Bought(request.Seller, request.Item, request.Quantity, unitPrice)) buyer.Mind.Memory
                            let sellerMemory =
                                recordMemory world.Tick (Sold(request.Buyer, request.Item, request.Quantity, unitPrice)) seller.Mind.Memory
                            newNpcs.[buyerIndex] <-
                                { buyer with
                                    Inventory = changeInventory request.Item request.Quantity buyer.Inventory
                                    Mind =
                                        { buyer.Mind with
                                            Needs = { buyer.Mind.Needs with Money = buyer.Mind.Needs.Money - total }
                                            Memory = buyerMemory } }
                            newNpcs.[sellerIndex] <-
                                { seller with
                                    Inventory = changeInventory request.Item (-request.Quantity) seller.Inventory
                                    Mind =
                                        { seller.Mind with
                                            Needs = { seller.Mind.Needs with Money = seller.Mind.Needs.Money + total }
                                            Memory = sellerMemory } }
                            let event =
                                { Tick = world.Tick
                                  Kind = TradeEvent(request.Buyer, request.Seller, request.Item, request.Quantity, unitPrice) }
                            TradeSucceeded { world with Npcs = newNpcs; Events = world.Events @ [ event ] }

    let chatableForChat (n: Npc) : bool =
        n.Mind.Action <> Sleep && n.Mind.Action <> Chat

    let findChatPartner (self: Npc) (pos: Vec2) (npcs: Npc[]) : NpcId option =
        let lastChatPartner =
            self.Mind.Memory
            |> List.tryPick (fun event ->
                match event.Kind with
                | Chatted partner -> Some partner
                | _ -> None)
        let pick (allow: Npc -> bool) =
            let mutable best = None
            let mutable bestD2 = chatRangeSq
            for o in npcs do
                if o.Id <> self.Id && chatableForChat o && allow o then
                    let dx = o.Pos.X - pos.X
                    let dy = o.Pos.Y - pos.Y
                    let d2 = dx * dx + dy * dy
                    if d2 < bestD2 then
                        bestD2 <- d2
                        best <- Some o.Id
            best
        match pick (fun o -> Some o.Id <> lastChatPartner) with
        | Some partner -> Some partner
        | None -> pick (fun _ -> true)

    let rumorDecayWeight (nowTick: int64) (eventTick: int64) : float32 =
        let age = max 0L (nowTick - eventTick)
        float32 (exp (-(log 2.0) * float age / float rumorHalfLifeTicks))

    let rumorStrengthAt (nowTick: int64) (rumor: RumorEvent) : float32 =
        rumor.Strength * rumorDecayWeight nowTick rumor.Tick

    let private latestRumorFor (receiver: NpcId) (world: World) : RumorEvent option =
        world.Rumors
        |> List.filter (fun rumor ->
            rumor.Receiver = receiver
            && rumor.Tick <= world.Tick
            && world.Tick - rumor.Tick <= rumorFreshnessTicks
            && rumorStrengthAt world.Tick rumor >= rumorMinimumStrength)
        |> List.sortByDescending (fun rumor ->
            let (RumorId id) = rumor.Id
            rumor.Tick, id)
        |> List.tryHead

    let private nextRumorId (world: World) : RumorId =
        let maxId =
            world.Rumors
            |> List.fold (fun current rumor ->
                let (RumorId id) = rumor.Id
                max current id) -1L
        RumorId(maxId + 1L)

    let private rumorIsDuplicate (request: ChatRequest) (parent: RumorEvent option) (world: World) : bool =
        let parentId = parent |> Option.map (fun rumor -> rumor.Id)
        world.Rumors
        |> List.exists (fun rumor ->
            rumor.Narrator = request.Narrator
            && rumor.Receiver = request.Receiver
            && rumor.Parent = parentId
            && rumor.Tick <= world.Tick
            && world.Tick - rumor.Tick <= rumorFreshnessTicks
            && rumorStrengthAt world.Tick rumor >= rumorMinimumStrength)

    let chat (request: ChatRequest) (world: World) : ChatResult =
        match findNpcIndex request.Narrator world.Npcs with
        | None -> ChatRejected(NarratorNotFound, world)
        | Some narratorIndex when request.Narrator = request.Receiver -> ChatRejected(ChatSameParticipant, world)
        | Some narratorIndex ->
            match findNpcIndex request.Receiver world.Npcs with
            | None -> ChatRejected(ReceiverNotFound, world)
            | Some receiverIndex ->
                let narrator = world.Npcs.[narratorIndex]
                let receiver = world.Npcs.[receiverIndex]
                if not (chatableForChat narrator) || not (chatableForChat receiver) then
                    ChatRejected(ParticipantNotChatable, world)
                else
                    let parent = latestRumorFor request.Narrator world
                    let newNpcs = Array.copy world.Npcs
                    let narratorMemory = recordMemory world.Tick (Chatted request.Receiver) narrator.Mind.Memory
                    let receiverMemory = recordMemory world.Tick (Chatted request.Narrator) receiver.Mind.Memory
                    newNpcs.[narratorIndex] <-
                        { narrator with
                            Mind =
                                { narrator.Mind with
                                    Action = Chat
                                    Target = receiver.Pos
                                    ActionAge = 0L
                                    EffectDone = false
                                    Memory = narratorMemory } }
                    newNpcs.[receiverIndex] <-
                        { receiver with
                            Mind =
                                { receiver.Mind with
                                    Action = Chat
                                    Target = narrator.Pos
                                    ActionAge = 0L
                                    EffectDone = false
                                    Memory = receiverMemory } }
                    let chatted = { world with Npcs = newNpcs }
                    if rumorIsDuplicate request parent world then
                        ChatSucceeded(None, chatted)
                    else
                        let rumor =
                            match parent with
                            | None ->
                                { Id = nextRumorId world
                                  Tick = world.Tick
                                  OriginTick = world.Tick
                                  Source = request.Narrator
                                  Narrator = request.Narrator
                                  Receiver = request.Receiver
                                  Parent = None
                                  Depth = 0
                                  Strength = 1.0f }
                            | Some parent ->
                                { Id = nextRumorId world
                                  Tick = world.Tick
                                  OriginTick = parent.OriginTick
                                  Source = parent.Source
                                  Narrator = request.Narrator
                                  Receiver = request.Receiver
                                  Parent = Some parent.Id
                                  Depth = parent.Depth + 1
                                  Strength = rumorStrengthAt world.Tick parent }
                        let receiverWithRumor =
                            { newNpcs.[receiverIndex] with
                                Mind =
                                    { newNpcs.[receiverIndex].Mind with
                                        Memory = recordMemory world.Tick (Rumor rumor.Id) newNpcs.[receiverIndex].Mind.Memory } }
                        newNpcs.[receiverIndex] <- receiverWithRumor
                        ChatSucceeded(Some rumor, { chatted with Npcs = newNpcs; Rumors = rumor :: world.Rumors })

    let rumorPath (world: World) (target: RumorId) : RumorEvent list =
        let rec collect (visited: Set<RumorId>) (current: RumorId) (acc: RumorEvent list) =
            if Set.contains current visited then []
            else
                match world.Rumors |> List.tryFind (fun rumor -> rumor.Id = current) with
                | None -> []
                | Some rumor ->
                    let nextVisited = Set.add current visited
                    match rumor.Parent with
                    | None -> rumor :: acc
                    | Some parent -> collect nextVisited parent (rumor :: acc)
        collect Set.empty target []

    let rumorTraceText (world: World) : string =
        let rumorIdValue (RumorId id) = id
        let npcIdValue (NpcId id) = id
        let invariant = System.Globalization.CultureInfo.InvariantCulture
        let ordered = world.Rumors |> List.sortBy (fun rumor -> rumorIdValue rumor.Id)
        let rows =
            ordered
            |> List.map (fun rumor ->
                let parent = rumor.Parent |> Option.map rumorIdValue |> Option.map string |> Option.defaultValue "-"
                let path =
                    rumorPath world rumor.Id
                    |> List.map (fun item -> item.Id |> rumorIdValue |> string)
                    |> String.concat ","
                let pathText = if path = "" then "-" else path
                sprintf "rumor id=%d tick=%d origin_tick=%d source=%d narrator=%d receiver=%d parent=%s depth=%d strength=%s path=%s"
                    (rumorIdValue rumor.Id)
                    rumor.Tick
                    rumor.OriginTick
                    (npcIdValue rumor.Source)
                    (npcIdValue rumor.Narrator)
                    (npcIdValue rumor.Receiver)
                    parent
                    rumor.Depth
                    (rumor.Strength.ToString("0.000000", invariant))
                    pathText)
        let header = sprintf "rumor_trace tick=%d count=%d" world.Tick world.Rumors.Length
        String.concat "\n" (header :: rows)

    let private stepNpc (tick: int64) (npcs: Npc[]) (pending: ResizeArray<InteractionEvent>) (npc: Npc) : Npc =
        let decayed =
            needsClamp
                { Hunger = npc.Mind.Needs.Hunger - hungerDecayPerTick
                  Energy = npc.Mind.Needs.Energy - energyDecayPerTick
                  Social = npc.Mind.Needs.Social - socialDecayPerTick
                  Money = npc.Mind.Needs.Money - moneyDecayPerTick }
        let night = isNightTick tick
        let age = npc.Mind.ActionAge + 1L
        let urgent = needsUrgent decayed
        let maxStep = npcSpeed * dtSecondsF
        let mind0 =
            { npc.Mind with
                Needs = decayed
                ActionAge = age
                HungerFlagged =
                    if decayed.Hunger < urgentThreshold then npc.Mind.HungerFlagged else false }
        let mind1 =
            if decayed.Hunger < urgentThreshold && not npc.Mind.HungerFlagged then
                { mind0 with Memory = recordMemory tick Hungry mind0.Memory; HungerFlagged = true }
            else mind0
        let switchTo (resetOnSame: bool) (mind: Mind) (needsNow: Needs) (pos: Vec2) : Npc =
            let action = decideAction night needsNow mind.Personality
            if action = Wander then
                match findChatPartner npc pos npcs with
                | Some partner ->
                    pending.Add { Tick = tick; Kind = ChatInit(npc.Id, partner) }
                    { npc with Pos = pos; Mind = mind }
                | None ->
                    if action = mind.Action then
                        if resetOnSame then
                            { npc with Pos = pos; Mind = { mind with ActionAge = 0L; EffectDone = false } }
                        else { npc with Pos = pos; Mind = mind }
                    else
                        { npc with
                            Pos = pos
                            Mind = { mind with Action = action; Target = actionTarget action; ActionAge = 0L; EffectDone = false } }
            elif action = mind.Action then
                if resetOnSame then
                    { npc with Pos = pos; Mind = { mind with ActionAge = 0L; EffectDone = false } }
                else { npc with Pos = pos; Mind = mind }
            else
                { npc with
                    Pos = pos
                    Mind = { mind with Action = action; Target = actionTarget action; ActionAge = 0L; EffectDone = false } }
        if mind1.Action = Chat then
            let struct (nextPos, _) = moveToward npc.Pos mind1.Target maxStep
            if age >= chatTicks then
                let needs2 = applyActionEffect Chat mind1.Needs
                switchTo true { mind1 with Needs = needs2 } needs2 nextPos
            else
                { npc with Pos = nextPos; Mind = mind1 }
        else
            let target = actionTarget npc.Mind.Action
            let struct (nextPos, arrived) = moveToward npc.Pos target maxStep
            if arrived then
                let needs2, mem2 =
                    if mind1.EffectDone then mind1.Needs, mind1.Memory
                    else
                        let mem =
                            match actionMemoryKind mind1.Action with
                            | Some k -> recordMemory tick k mind1.Memory
                            | None -> mind1.Memory
                        applyActionEffect mind1.Action mind1.Needs, mem
                let mind2 = { mind1 with Needs = needs2; Memory = mem2; EffectDone = true }
                if age >= minActionTicks || urgent then
                    switchTo true mind2 needs2 nextPos
                else
                    { npc with Pos = nextPos; Mind = mind2 }
            elif urgent && age < minActionTicks then
                switchTo false mind1 decayed nextPos
            else
                { npc with Pos = nextPos; Mind = mind1 }

    let step (ts: TimeStep) (world: World) : World =
        let tick = world.Tick + 1L
        let maxX = float32 (mapWidthTiles * tilePixels - tilePixels)
        let maxY = float32 (mapHeightTiles * tilePixels - tilePixels)
        let dx = ts.Input.MoveX * avatarSpeed * dtSecondsF
        let dy = ts.Input.MoveY * avatarSpeed * dtSecondsF
        let rngOut, rngNext = Rng.nextUInt64 world.Rng
        ignore rngOut
        let pending = ResizeArray<InteractionEvent> ()
        let oldNpcs = world.Npcs
        let newNpcs = Array.copy oldNpcs
        for i in 0 .. newNpcs.Length - 1 do
            newNpcs.[i] <- stepNpc tick oldNpcs pending newNpcs.[i]
        let queue = if pending.Count = 0 then world.Events else world.Events @ List.ofSeq pending
        let baseWorld =
            { world with
                Tick = tick
                Time = float tick * dtSeconds
                Rng = rngNext
                Avatar =
                    { Pos =
                        { X = clamp (world.Avatar.Pos.X + dx) 0.0f maxX
                          Y = clamp (world.Avatar.Pos.Y + dy) 0.0f maxY } }
                Npcs = newNpcs }
        let mutable nextWorld = baseWorld
        for ev in queue do
            match ev.Kind with
            | ChatInit (a, b) ->
                match chat { Narrator = a; Receiver = b } nextWorld with
                | ChatSucceeded (_, updated) -> nextWorld <- updated
                | ChatRejected (_, _) -> ()
            | TradeEvent _ -> ()
        { nextWorld with Events = [] }

    // ---- 关系网派生：rel(i,j) = sum(Chatted valence * exp(-ln2*(now-tick)/HALF_LIFE))（真半衰：age=HALF_LIFE 处权重恰 0.5）----

    let relationDecayWeight (nowTick: int64) (eventTick: int64) : float32 =
        let age = float (nowTick - eventTick)
        float32 (exp (-(log 2.0) * age / float relationHalfLifeTicks))

    // 30x30 对称矩阵（对角线 0）：双向累加双方 Chatted 记忆的衰减 valence
    let relationMatrix (world: World) : float32[,] =
        let n = world.Npcs.Length
        let m = Array2D.zeroCreate n n
        for npc in world.Npcs do
            let i =
                match npc.Id with
                | NpcId i -> i
            for e in npc.Mind.Memory do
                match e.Kind with
                | Chatted partner when e.Tick <= world.Tick ->
                    let j =
                        match partner with
                        | NpcId j -> j
                    if i <> j && i < n && j < n then
                        let w = e.Valence * relationDecayWeight world.Tick e.Tick
                        m.[i, j] <- m.[i, j] + w
                        m.[j, i] <- m.[j, i] + w
                | _ -> ()
        m

    let relationCounts (m: float32[,]) : int[] =
        let n = Array2D.length1 m
        Array.init n (fun i ->
            let mutable c = 0
            for j in 0 .. n - 1 do
                if i <> j && abs m.[i, j] > relationThreshold then c <- c + 1
            c)