package routers

import (
	"context"
	"sync"
)

var _ = sync.Mutex{}
var _ = context.Background

// 
// Combat authority for CLIENT-SPAWNED enemies.
// The enemy this covers is the one produced by the in-game local channel
// (GmUtils.CreateClientAgent / LuaUtils.CreateClientAgentByCfg). That unit belongs to
// the client: it lives in the client's LocalUnitMgr, it carries its own HP / death
// model / animation layer, and this server has no record of it at all. Nothing drives
// that model either — the client's combat sim never applies damage to a local unit, so
// the enemy absorbs every shot without flinching and never dies. Logs confirm the
// player's hits DO arrive here (AskMultipleSkillHit2 with the local unit's uid in
// HitTarget, firearms included), which means the server is the only missing link.
// This file closes that link without touching how enemies are created and without
// creating an entity server-side:
// 1. LAZY LEDGER. The first time a hit names a local unit, its uid is recorded. No
// spawn packet is sent, the client's unit is left exactly as it is; the server
// only starts remembering "this uid has an HP pool".
// 2. FEEDBACK. Every accepted hit broadcasts the hurt effect, a one-shot stagger and the
// authoritative HP ratio. SyncUnitHurtEffect (68349329) is the important one: the
// client fastpatch defines a Lua impl for it that forwards the payload into
// gCS.BattleManager.LuaTryDoHurtAction, i.e. the client's OWN hurt pipeline, keyed by
// pid. That is what makes the enemy actually flinch - and it is the right lever,
// because the animation state machine owns the Animator and rewrites the pose from its
// own State every frame, so any one-off PlayAction we sent would read as a twitch that
// instantly recovers. SyncUnitHp is resolved through gCS.SceneDataMgr.GetUnit(pid), the
// same global lookup that also serves LocalUnitMgr, which is why server packets can
// reach a client-owned unit at all.
// 3. DEATH. At zero HP the unit runs the down pose -> death beat -> loot drop -> despawn
// chain. The step that matters on screen is the last one, SyncRemoveNpc, and it depends
// on the same fastpatch: the retail build declares that method LuaOnly and ships its
// reader, but never defines an impl, so the dispatcher's name lookup found nothing and
// the packet was dropped on arrival without a log line. The patch's impl removes the
// unit through BaseUnitUtils.DestroyAgentUnit left non-forced, which routes into
// LocalUnit.OnDead and lets it play the death beat and schedule its own delayed destroy
// instead of deleting the unit outright.
// The stagger packets (67149 / 88300) ARE the reaction path. SyncEnemyPlayAction
// (68039914) is declared CSharpOnly and RPCDeserializeAuto ships neither a midToReader
// nor a midToName entry for it, so the Lua dispatcher used to return false on the
// missing reader before it ever looked up a handler and the packet reached only the
// native C# impl - which resolves units through registries a LocalUnit is not in.
// The client fastpatch now injects those two map entries at runtime (reader =
// u64 uid, u32 actionId, f32 maxTime, i.e. this file's EnemyPlayActionData4229938)
// plus a Lua impl, so these packets land and drive the pose. Keep sending them.
// Two deliberate exclusions keep the two spawn paths from colliding:
// * units this server spawned (admin panel / GM channel) own uid >= ServerSpawnUidFloor and
// are handled by GameAdminBridge — a lazy ledger entry there would double up;
// * the player's own unit ids are never treated as enemies. Note the player entity is
// 0x200000000001 (client-allocated), NOT Profile.InitialUnitId — before the ordinal
// offset was introduced it sat above the floor and was settled as an enemy.
// Feature switch: create an empty file named "local-enemy-combat.disabled" next to
// Drmk.App.exe and restart the server to turn the whole path off.
// 
func GameRouter_LocalEnemyCombat_GetLocalEnemyRuntimeState(ctx context.Context, session *GameSession) any {
	// Router implementation for GameRouter_LocalEnemyCombat_GetLocalEnemyRuntimeState
	var zero any; return zero
}

func GameRouter_LocalEnemyCombat_LocalEnemyCombatEnabled(ctx context.Context, ) bool {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyCombatEnabled
	return true
}

// ------------------------------------------------------------------
// Registration of SERVER-SPAWNED agents (GameAdminBridge.SpawnAgentAsync).
//
// A server-spawned agent is a real battle unit: the client creates it from
// SyncRaidBattleUnitAgent and its native code can see it, so SyncEnemyPlayAction
// (CSharpOnly) actually reaches an animation layer — unlike a client-spawned local
// unit, where those same packets are dropped because the uid is not in the native
// registry. That single difference is why this path is the reliable one for
// stagger + death, and why SpawnAgentAsync registers its agents here instead of
// relying on the lazy hit-ledger below.
// ------------------------------------------------------------------
// Puts a freshly spawned agent into the HP ledger so its hits are settled.
// Called by GameAdminBridge.SpawnAgentAsync right after the spawn batch.
func GameRouter_LocalEnemyCombat_RegisterSpawnedEnemy(ctx context.Context, session *GameSession, uid uint64, enemyId uint32, position Vec3, playerUnit uint64, facing float32) any {
	// Router implementation for GameRouter_LocalEnemyCombat_RegisterSpawnedEnemy
	var zero any; return zero
}

// 
// Hostile activation: lock the player, give the fight edict, keep the weapon and
// raise the detect flag. All four are needed — the behaviour tree only leaves idle
// once it has a target AND the fight edict AND a detection.
// Deliberately NOT re-sent on every hit. LY-3.3 proved that re-sending these four
// packets per hit resets the client's enemy action layer, which cut every stagger
// short: firearms survived it (slow enough to recover between shots) while melee
// degenerated into "first swing animates, the rest twitch". Engagement is owned by
// spawn plus the one delayed re-send below.
// 
func GameRouter_LocalEnemyCombat_EngageSpawnedEnemyAsync(ctx context.Context, session *GameSession, uid uint64, playerUnit uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_EngageSpawnedEnemyAsync
	var zero any; return zero
}

// Re-sends the engagement batch 1.5s after spawn: the first batch can be
// consumed before the client finishes initialising the unit.
func GameRouter_LocalEnemyCombat_ReEngageSpawnedEnemyAsync(ctx context.Context, session *GameSession, uid uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_ReEngageSpawnedEnemyAsync
	var zero any; return zero
}

// ------------------------------------------------------------------
// Hit intake.
// ------------------------------------------------------------------
// 
// Damages a client-spawned enemy named by a hit report and drives its reaction.
// Called from OnSkillHit BEFORE the weapon-sandbox validation so a local enemy still
// takes damage when the skill is not in the sandbox's allow-list — the same ordering
// rationale the LY-3.3 reference server used, and the reason its enemies stayed
// defeatable while its weapon rules changed.
// 
func GameRouter_LocalEnemyCombat_TrackLocalEnemyHitAsync(ctx context.Context, rpcCtx *RpcContext, hit any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_TrackLocalEnemyHitAsync
	var zero any; return zero
}

// ------------------------------------------------------------------
// Outgoing reactions.
// ------------------------------------------------------------------
// Authoritative hit notification: SyncUnitAttacked(68299892).
// This is the one hit packet the client's NATIVE combat code handles (CSharpOnly, no Lua
// reader), which is why it only ever does anything for a unit the native side can see —
// i.e. a server-spawned agent. It is still sent for client-spawned local units because a
// dropped packet costs nothing and the shape is now known to be correct.
// ⛑⛑ PoiseBasicValue 填的是 EnemyCombatSettings.PoiseDrainPerHit，和服务端自己的
// 架势账本是同一个数，两边同步破防。
// 历史：这里填过 damage(100)，客户端架势池就是 100 ⇒ 每一下都打空 ⇒ 每一下都进虚弱/倒地，
// 而当时没有退出通道（没有 ReportUnitStandUp 回执、没有 SyncEnemyDisarmState(false)、
// 没有超时兜底），敌人就永久卡在破防里 —— 那正是 2026-09-23 上午"受打击反馈正常但打不死"
// 的完整解释。14:4x 把它改成 0（donor 值）解决了卡住，但也把反馈改没了；现在退出通道齐了，
// 这个值可以按手感自由调：100 = 每下破防（反馈最强）/ 34 = 三下破防 / 0 = 不破防。
// 
// 2026-09-24 00:2x 曾加过「致死那一击 PoiseBasicValue 传 0」（poiseDrainOverride），
// 01:2x 已按用户要求撤掉：它让倒地动画播出来了，但玩家的后续攻击会把倒地顶掉。
// 23:27 实测正常的一版就是**不加这个特例**。`poiseDrainOverride` 参数保留但现在没有调用点传值，
// 将来若再要单独控制致死击的架势，改调用点即可。
// Resolve the attacker unit id for a hit.
// ⛑⛑⛑ 2026-09-26（伤害数字攻坚·离线取证结论）：回退值不能用 Profile.PlayerPid。
// 客户端画飘字的唯一入口是 LX6.Utils.GuiUtils.HurtFloat（RVA 0x14824610，
// 全 .text 只有一处调用点：SyncUnitAttacked 消费函数 0x1275F320 内的 0x1276261B），
// 它在调用 ShowHurtMsg 之前判一条：
// <code>
// 0x148246CC  test r12,r12 / call get_IsMe()   // unit
// 0x148246E0  test r15,r15 / call get_IsMe()   // attacker
// 0x148246F7  test rbx,rbx / call get_IsMe()   // realAttacker
// 0x1482470E  je  0x14824744                   // 三者全非 IsMe -> 只打 Warn(HurtFloatText=371) 后返回
// 0x1482472C  jmp ShowHurtMsg                  // 有一方 IsMe -> 画飘字
// </code>
// 而 attacker 是 SyncUnitAttacked.attackerId 经
// GetUnit → GetNpcByPid → Unit_GetByPid 三段解析出来的（0x1275F48D/4AF/882），
// 三段全落空 ⇒ attacker = null ⇒ 上面那条 IsMe 判据拿不到 true ⇒ 不画飘字。
// Profile.PlayerPid 是 json player.pid（我们 = 100，捐赠端 = 666），
// 那是账号 pid，不在 unit id 空间里，三段必然全落空。
// 捐赠端 7k-v0.5 GameRouter.Enemy.cs:400-402 回退的是
// world?.ActiveSpiritUnitId ?? Profile.InitialUnitId（unit id 空间），所以它能过。
// 开关 EnemyCombatSettings.AttackerIdFallbackToSpiritUnit（默认 true）。
func GameRouter_LocalEnemyCombat_ResolveLocalHitAttackerId(ctx context.Context, rpcCtx *RpcContext, hit any) uint64 {
	// Router implementation for GameRouter_LocalEnemyCombat_ResolveLocalHitAttackerId
	return 0
}

func GameRouter_LocalEnemyCombat_SendLocalEnemyAttackedAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64, hit any, damage float32, serverSpawned bool, poiseDrainOverride any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyAttackedAsync
	var zero any; return zero
}

// Hurt VFX on the target, and - since the client fastpatch defines a Lua impl
// for SyncUnitHurtEffect - the trigger for the actual hit reaction: the fastpatch feeds
// these fields straight into gCS.BattleManager.LuaTryDoHurtAction, so the client runs its
// own hurt pipeline on the locally spawned unit instead of the packet falling through to
// a native handler that cannot see it. `hurtId` is the hit's own HurtEffectId so the
// client plays the effect the weapon authored; 1 = normal impact.
// HurtEffectFacePos carries the real impact point, not the surface normal: the client
// reports ClientHitPosNormalDir as (0,0,0) on every shot (decoded byte-for-byte from
// packets-latest.log), so the normal would have placed the reaction at the world origin.
// 2026-09-26：`HurtImpact` / `HurtLeftOrRightHit` 不再硬编码，改由
// ResolveLocalHurtPresentation 查 HurtEffectCatalog.json。
func GameRouter_LocalEnemyCombat_SendLocalEnemyHurtEffectAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64, hit any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyHurtEffectAsync
	var zero any; return zero
}

// 2026-09-26 Wave 1：LocalEnemyBulletHurtPresentation（55001201，7K 枪械整行替换的
// 目标行，表里 Impact=1 / LeftOrRight=0 / SoundId=0）随「整行替换」语义一起移除 ——
// 现在的枪械分支是只升不降（保留作者行），不再引用它。行值留在这条注释里备查。
// 
// 按 hit.HurtEffectId 解析出这次命中该发的表现参数。
// 移植自捐赠端 7k-v0.5 GameRouter.Enemy.cs:590 ResolveHurtPresentation。
// 关键差异（有意为之）：捐赠端无条件走枪械重定向，我们把它放在
// EnemyCombatSettings.HurtEffectBulletOverride 后面 —— 见那个开关的注释。
// 2026-09-26 Wave 1 起该分支从「整行替换成 55001201」改成只升不降：
// 保留作者行，只把 Impact 抬到 ≥ 2。7K 的替换会把 3 行 Impact=4 的作者配置
// （55004539 / 55004615 / 55004741，还带 SoundId=70400806）打成 Impact=2 / 无声。
// ⛑ 下限夹到 1 是必须的：1841 行里有 306 行 Impact = 0，照发就是"完全没反应"，
// 比原来的硬编码 1 还差。查表未命中同样兜到 1，保证不劣化。
// 
func GameRouter_LocalEnemyCombat_ResolveLocalHurtPresentation(ctx context.Context, hurtEffectId uint32) any {
	// Router implementation for GameRouter_LocalEnemyCombat_ResolveLocalHurtPresentation
	var zero any; return zero
}

// 
// HP bar baseline, sent once the first time a unit enters the ledger.
// Two packets and the order is not optional:
// 1. SyncUnitAttrs with attrs[1] = MaxHp (AttributeNameConfig Id=1 is Max HP). Without
// this the unit has no MaxHp at all and there is nothing for a bar to be a
// fraction of.
// 2. SyncUnitHp with the ABSOLUTE hp, not a ratio. Sending 1.0 for "full" is what made
// the bar missing: the client reads the value against MaxHp, so 1.0 against a
// 1000 MaxHp is a sliver, and against a MaxHp of 0 it is nothing at all.
// Unit of measure deliberately matches the ledger (LocalEnemyMaxHp，2026-09-27 起由
// `gameplay.combat.enemies.maxHp` 驱动，默认 1000 / 现配 1500): the donor
// build settled on exactly the same numbers, so hit counts stay comparable.
// 
func GameRouter_LocalEnemyCombat_SendLocalEnemyHpBaselineAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64, maxHp float32) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyHpBaselineAsync
	var zero any; return zero
}

// 
// Authoritative HP, in absolute units (0 .. MaxHp), NOT a ratio.
// Deliberately the LAST packet of a hit: the client's Lua handler for this one touches
// unit.ClientData.MaxHp, and a local unit's ClientData is the one field on this path
// that could be nil. Sending it last means a client-side error there cannot cost the
// player the visible flinch or the hurt VFX.
// 
func GameRouter_LocalEnemyCombat_SendLocalEnemyHpAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64, hp float32) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyHpAsync
	var zero any; return zero
}

// Throttled one-shot stagger. Delayed so the hurt VFX has landed first, and
// rate-limited per enemy so a fast melee combo cannot cut the flinch short.
// Caveat, established from the client's own dispatch tables: this action packet is
// handled by the native C# impl of SyncEnemyPlayAction, not by Lua. 68039914 has no
// midToReader and no midToName entry, and RPCDeserializeBase returns early on a
// missing reader, so the Lua impl (and any fastpatch on top of it) is never reached.
// It is now also consumed by Lua: the fastpatch injects the missing midToReader /
// midToName entries for 68039914 and installs an impl that resolves the unit's
// action group through ActionManager and plays the action. Expect the client's
// hit-state guard to swallow none of them (it is deliberately not reproduced).
// 
func GameRouter_LocalEnemyCombat_SendLocalEnemyStaggerAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyStaggerAsync
	var zero any; return zero
}

func GameRouter_LocalEnemyCombat_ReassertLocalEnemyDeathAsync(ctx context.Context, session *GameSession, uid uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_ReassertLocalEnemyDeathAsync
	var zero any; return zero
}

// 把倒地动作 88300 推给一个已经在走死亡流程的单位（不带节流）。
// 节流由调用方按自己的节奏做：AskAgentEnterStiff 上报走
// ReassertLocalEnemyDeathAsync，周期扫描由 SweepLocalEnemyDeathClearsAsync 自己做。
func GameRouter_LocalEnemyCombat_SendLocalEnemyDownPoseAsync(ctx context.Context, session *GameSession, uid uint64, why string) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyDownPoseAsync
	var zero any; return zero
}

// 虚弱窗口内把硬直姿势顶回去：SyncEnemyPlayAction(67149)。
// 2026-09-23 17:1x 实测：破防后客户端只是站着（SyncEnemyDisarmState / SyncEnemyPoiseRate 在这个
// build 里都是空实现），5 s 后照常挥击，玩家读作"打晕没有动画"。一次性动作撑不满 5 s 的窗口，
// 所以由 MaintainLocalEnemyGroggyAsync 按 LocalEnemyGroggyReassertMs 周期重推，直到窗口关闭
// （ExitLocalEnemyGroggyAsync 会清掉节流记录）。
func GameRouter_LocalEnemyCombat_SendLocalEnemyGroggyPoseAsync(ctx context.Context, session *GameSession, uid uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_SendLocalEnemyGroggyPoseAsync
	var zero any; return zero
}

// 虚弱窗口内客户端又上报一次硬直时的即时补推（节流 LocalEnemyStiffNudgeMs）。
// 为什么需要它：MaintainLocalEnemyGroggyAsync 只在 AI tick 上按 LocalEnemyGroggyReassertMs
// 周期补推，而"倒地被顶掉"是客户端先知道的 —— 它受击命中后立刻上报 AskAgentEnterStiff。
// 等周期到点再补，中间那一段敌人就是站着的（玩家读作"打晕没动画 / 只有挨打反应"）。
// 这里收到上报就补一次；与周期补推共用 LastGroggyReassert 节流表，两者不会叠成每帧一次。
func GameRouter_LocalEnemyCombat_ReassertLocalEnemyGroggyAsync(ctx context.Context, session *GameSession, uid uint64) any {
	// Router implementation for GameRouter_LocalEnemyCombat_ReassertLocalEnemyGroggyAsync
	var zero any; return zero
}

// 
// Death sequence for a local unit, in the order the client can actually consume:
// down pose -> death beat (EnemyDieInfo) -> loot drop -> LogicAgentLeave -> SyncRemoveNpc
// probe. Each step is separated so one that is dropped client-side does not take the
// next one with it, and every send is individually guarded.
// The last two steps are the removal half. SyncLogicAgentLeave routes through
// LogicAgentMgr and does not know LocalUnitMgr entries, so it is a no-op for this kind of
// unit and is kept only for the case where the target happens to be a real logic agent.
// SyncRemoveNpc is the step that actually lands: the fastpatch installs the Lua impl the
// retail build is missing, and that impl runs the destroy cascade. Both are still sent so
// one test tells them apart in the log.
// 
func GameRouter_LocalEnemyCombat_LocalEnemyDeathSequenceAsync(ctx context.Context, rpcCtx *RpcContext, uid uint64, deadlySkillId uint32, deathPos Vec3) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyDeathSequenceAsync
	var zero any; return zero
}

// ------------------------------------------------------------------
// Client-reported combat C2S. These are accepted for observability: nothing here
// changes server state except the fall handshake, and each one logs what the client
// itself believes happened. All arguments are read defensively.
// ------------------------------------------------------------------
// Defensive read of the single-u64 unit reference used by the fall handshake.
// These three methods carry one ulong argument (verified in-game on this build), so the
// read is a bare u64 rather than a guessed struct; a failure yields 0 and the caller
// simply does not answer.
func GameRouter_LocalEnemyCombat_TryReadUnitId(ctx context.Context, msg any) uint64 {
	// Router implementation for GameRouter_LocalEnemyCombat_TryReadUnitId
	return 0
}

// 
// Raw body of a report whose wire shape is not verifiable on this build. Used instead of
// parsing: guessing a struct here would either throw or silently mis-read, whereas the
// hex dump in the log is itself the evidence needed to define the contract later.
// 
func GameRouter_LocalEnemyCombat_RawBody(ctx context.Context, msg any) string {
	// Router implementation for GameRouter_LocalEnemyCombat_RawBody
	return ""
}

// 
// Hurt-effect feedback. Recorded raw and NOT re-broadcast: the server already sends the
// hurt effect from the authoritative hit, so echoing this one would double the VFX on
// every melee swing. Whether the client emits this for a local unit at all is exactly
// what the log line answers.
// Registered for BOTH packet kinds and answered with an empty OK on invoke. The older
// ANANAS server returned SendEmptySuccessReturn for every one of these combat reports,
// which means the client may send them as invokes expecting a reply; a notify-only
// registration would leave that callback outstanding.
func GameRouter_LocalEnemyCombat_LocalEnemyHurtEffectReport(ctx context.Context, conn any, msg any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyHurtEffectReport
	var zero any; return zero
}

// 
// The client's own combat sim announces the killing blow on a unit it owns. When that
// unit is one we track, the down pose and death beat are played immediately: the client
// hides the unit if the server stalls here, so answering late is as bad as not answering.
// Registered for BOTH packet kinds: the older ANANAS server answered this handshake with
// an empty OK, so an invoke form has to be replied to even when the unit is untracked.
// 
func GameRouter_LocalEnemyCombat_LocalEnemyStartFall(ctx context.Context, conn any, msg any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyStartFall
	var zero any; return zero
}

// 
// The client finished the fall. Drop the loot and remove the unit, then forget it.
// Both packet kinds, empty OK on invoke.
// 
func GameRouter_LocalEnemyCombat_LocalEnemyEndFall(ctx context.Context, conn any, msg any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyEndFall
	var zero any; return zero
}

// Fall handshake acknowledgement point — logged, and always acknowledged.
// Both packet kinds, empty OK on invoke.
func GameRouter_LocalEnemyCombat_LocalEnemyFallGround(ctx context.Context, conn any, msg any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyFallGround
	var zero any; return zero
}

// 
// The client reports a unit casting a skill. Direct evidence that a unit's client-side
// AI is acting, so it is recorded raw (the wire shape is CSharpOnly and unverifiable on
// this build) rather than parsed — a locally generated enemy that fights back shows up
// in the console this way. Both packet kinds, empty OK on invoke.
// 
func GameRouter_LocalEnemyCombat_LocalEnemyUseClientSkill(ctx context.Context, conn any, msg any) any {
	// Router implementation for GameRouter_LocalEnemyCombat_LocalEnemyUseClientSkill
	var zero any; return zero
}

type LocalEnemyRecord struct {
	Uid uint64 `json:"uid"`
	MaxHp float32 `json:"maxHp"`
	Hp float32 `json:"hp"`
	Hits int32 `json:"hits"`
	FirstSeenTicks int64 `json:"firstSeenTicks"`
	LastStiffTicks int64 `json:"lastStiffTicks"`
	Position Vec3 `json:"position"`
	LastSkillId uint32 `json:"lastSkillId"`
	LastHurtEffectId uint32 `json:"lastHurtEffectId"`
	Dead bool `json:"dead"`
	DeathStarted bool `json:"deathStarted"`
// True when this record was created by SpawnAgentAsync rather than
// discovered from a hit report. Server-spawned agents are real battle units the
// client's native code can see, so they are engaged and despawned through the
// agent channel; client-spawned local units need the local-unit removal path
// instead. Template id and locked player unit are kept for logging and re-engage.
	ServerSpawned bool `json:"serverSpawned"`
	EnemyId uint32 `json:"enemyId"`
	PlayerUnit uint64 `json:"playerUnit"`
// ---- Poise / groggy (stance) state ----
// Current stance pool. Drains per hit, not per damage point: a heavy hit and a
// light one cost the same, which is what makes the bar readable and predictable.
	Poise float32 `json:"poise"`
// TickCount64 until which the enemy is staggered and stops swinging.
// 0 = not groggy. The pool refills when the window closes — see
// ExitLocalEnemyGroggyAsync (GameRouter.EnemyStiff.cs), which is also the place that
// pushes SyncEnemyDisarmState(false) + a full stance bar back to the client.
	GroggyUntilTicks int64 `json:"groggyUntilTicks"`
// True while the client has told us (AskAgentEnterStiff) the unit is in 硬直.
// Cleared by AskAgentExitStiff / ReportUnitStandUp — see GameRouter.EnemyStiff.cs.
	StiffActive bool `json:"stiffActive"`
// How many times this enemy has been broken. Logging only.
	GroggyCount int32 `json:"groggyCount"`
// ---- 2026-10-02 逐字对齐捐赠端 EnemyRecord 的收押/攻击 AI 字段 ----
// 主线原本没有这些（旧 PolicePrison.cs 靠改账本坐标 + AttackAiEnabled=false 顶替）。
// 现在捐赠端 GameRouter.PolicePrison.cs 逐字落地 ⇒ 把这些状态补上，**纯新增、不改既有语义**。
	IsPoliceDetained bool `json:"isPoliceDetained"`
	AttackAiFollowing bool `json:"attackAiFollowing"`
	AttackAiFollowTarget uint64 `json:"attackAiFollowTarget"`
// AttackAiTarget / AttackAiCastSkill / AttackAiCastUntil 主线本来就有 ⇒ 不重复加。
	AttackAiCastTarget uint64 `json:"attackAiCastTarget"`
	HackBusyUntilTicks int64 `json:"hackBusyUntilTicks"`
	SceneGeneration int32 `json:"sceneGeneration"`
// ---- Alertness / enemy-HUD state (GameRouter.EnemyWarning.cs) ----
// 
// 已经注册过警戒状态机。false = 客户端那边还是 EnemyDetectState.None，
// HUD（血条 + 挂它上面的警戒条）不会绑 —— 这就是"血条默认不显示"。
// 
	WarningPrimed bool `json:"warningPrimed"`
// 最近一次下发的 detectionState（0 None / 1 Idle / 2 Suspect / 3 Alert / 4 Fight）。
	WarningState byte `json:"warningState"`
// 
// 注册后剩余的重试次数。模型/occur 重建会把早期那份 HUD 快照丢掉，
// 所以刚注册的两拍里即使状态没变也要重发（捐赠端 Warmup=2）。
// 
	WarningWarmupRemaining int32 `json:"warningWarmupRemaining"`
// 下一次允许重估/重发的 TickCount64。状态不变就在这里直接跳过，避免刷包。
	WarningRefreshAt int64 `json:"warningRefreshAt"`
// ---- 血条显示时机（GameRouter.EnemyHpBar.cs）----
// 
// 服务端给这个单位挂了 UnitStateConfig.HideHp(10266)，血条此刻是收起的。
// 第一次命中时由 RevealLocalEnemyHpBarAsync 撤掉状态并置回 false。
// 
	HpBarHidden bool `json:"hpBarHidden"`
// ---- Attack-AI state (GameRouter.EnemyAiActions.cs) ----
	AttackAiEnabled bool `json:"attackAiEnabled"`
	AttackAiTarget uint64 `json:"attackAiTarget"`
	AttackAiActionAt int64 `json:"attackAiActionAt"`
	AttackAiCastSkill uint32 `json:"attackAiCastSkill"`
	AttackAiCastUntil int64 `json:"attackAiCastUntil"`
	AttackAiCastInstance int32 `json:"attackAiCastInstance"`
	AttackAiCastCount int32 `json:"attackAiCastCount"`
	AttackAiMoveId byte `json:"attackAiMoveId"`
	AttackAiMoveCount int32 `json:"attackAiMoveCount"`
	LastHurtFeedbackTicks int64 `json:"lastHurtFeedbackTicks"`
// Spawn facing, kept so the turn command can compute a delta angle.
	Facing float32 `json:"facing"`
// 
// 出生点。踱步的保险绳基准：估算位置离它超过 EnemyAiPatrolLeashMeters 就强制换向，
// 免得估算误差累积把敌人一路推到玩家脸上。
// 
	HomePosition Vec3 `json:"homePosition"`
// 踱步方向：true = 下一步朝玩家（WalkFront），false = 下一步背对玩家退（WalkBack）。
	PatrolForward bool `json:"patrolForward"`
// engagement 状态上次翻转的 TickCount64，用于 EnemyAiEngageHoldMs 防抖。
	AttackAiEngageChangedAt int64 `json:"attackAiEngageChangedAt"`
// Estimated, NOT authoritative. The client owns the unit's real position
// after a move command and reports it back without coordinates, so this is walked
// towards the player by GameRouter.EnemyAiMoveStepMeters per dispatch.
// Only used to decide "close enough to swing yet".
	AiPosition Vec3 `json:"aiPosition"`
}

type LocalEnemyRuntimeState struct {
	SyncRoot any `json:"syncRoot"`
	Enemies map[uint64]LocalEnemyRecord `json:"enemies"`
// TickCount64 deadlines for corpses that still need to be torn down.
// SyncEnemyPrepareDie only makes the client PLAY the death; the unit itself is removed by
// SyncClearSpoonEnemies. Entries are added by the death sequence and removed either by the
// client's own report (ReportEnemyPrepareFinish / ReportAgentDiePerfEnd) or by the grace
// timeout — see GameRouter.EnemyStiff.cs. Before this existed the corpse was never removed
// at all, which is the "killed it and it came back, now unkillable" report.
	PendingDeathClear map[uint64]int64 `json:"pendingDeathClear"`
// TickCount64 of the last time the down pose was re-pushed onto a corpse.
// 尸体被玩家连招再次打进硬直时用来节流（见 ReassertLocalEnemyDeathAsync）。
// 尸体拆掉时随 PendingDeathClear 一起清理。
	LastDeathReassert map[uint64]int64 `json:"lastDeathReassert"`
// 尸体最早允许被拆掉的 TickCount64（= 死亡序列开始 + LocalEnemyMinCorpseMs）。
// 2026-09-23 19:2x：客户端会在死亡动画刚起手时就上报 ReportEnemyPrepareFinish /
// ReportAgentDiePerfEnd，而这两个 handler 原来是收到即拆（SyncClearSpoonEnemies），
// 于是同一套死亡序列会随机表现成两种结果 —— 上报来得早就"直接消失"，来得晚才"正常倒地"。
// 这正是"死亡动作不一定能加载出来"的来源。加了这个下限之后，客户端的报告只能把清理
// 提前到下限，不能提前到动画播完之前。
	DeathEarliest map[uint64]int64 `json:"deathEarliest"`
// TickCount64 of the last time the 硬直 pose was re-pushed onto a 虚弱 enemy.
// 虚弱窗口有 5 s，而客户端的 SyncEnemyPlayAction 是一次性动作、播完就站起来，
// 所以窗口内必须周期性重推，敌人看起来才是"被打晕了"而不是"站着发呆"
// （见 ReassertLocalEnemyGroggyAsync）。虚弱结束时清理。
	LastGroggyReassert map[uint64]int64 `json:"lastGroggyReassert"`
// Guards against starting a second attack-AI worker for the same session.
// One worker drives every spawned enemy; it exits once nothing is left to drive.
	AttackAiWorkerStarted bool `json:"attackAiWorkerStarted"`
// 
// TickCount64 deadlines at which the player's control states get released, queued by
// the attack AI when it dispatches a cast. See EnemyAiUnlockDelayMsEarly/Late.
// 
	PendingUnlocks []int64 `json:"pendingUnlocks"`
// Auto-release on/off. Toggled from the admin panel; on by default.
	AutoUnlockEnabled bool `json:"autoUnlockEnabled"`
// ---- 2026-10-02 逐字对齐捐赠端 EnemyRuntimeState 补的三个成员 ----
// 捐赠端 GameRouter.Enemy.cs:116 的 `GetEnemyRuntimeState` 返回 `EnemyRuntimeState`；
// 主线这套被 `LocalEnemyRuntimeState` 取代，字段命名也不同。这里**只加字段、不改语义**，
// 让捐赠端 GameRouter.PolicePrison.cs / LixiPolice.cs 能逐字编译。访问器别名在
// GameRouter.PoliceDonorGlue.cs。
	HackDispatchGate *sync.Mutex `json:"hackDispatchGate"`
	AttackAiWorkerGeneration int32 `json:"attackAiWorkerGeneration"`
	AttackAiWorkerId int64 `json:"attackAiWorkerId"`
}