441 lines
22 KiB
C#
441 lines
22 KiB
C#
using System.Collections.Concurrent;
|
||
using Ananta.SDK.Network;
|
||
using Ananta.SDK.Serialization;
|
||
using Ananta.Server.Configuration;
|
||
using Ananta.Server.Protocol.Client4229938;
|
||
using SceneMethods = Ananta.Server.RpcTypes.Client4229938.Methods.GameScene;
|
||
|
||
namespace Ananta.Server.Handlers.Game;
|
||
|
||
/// <summary>
|
||
/// 随从的<b>服务端兜底驱动</b>：跟随 + 协战。
|
||
///
|
||
/// ⛑⛑⛑ 2026-10-01 定位到更正的解法，本文件已<b>不再是默认路径</b>
|
||
/// （开关 <c>gameplay.aether.companionServerDrive</c>，默认 false）：
|
||
/// 随从模板用的是专属伴生行为树（晴 <c>Companion_JiaMu_Shuangmawei</c>、
|
||
/// 盖斯 <c>Companion_Guys</c>），它们的<b>行为集里没有</b> Behavior_Battle 和 RelatedSkillIds，
|
||
/// 战斗能力写在那棵树的 C# 实现里，服务端查不到 ⇒ 硬喂招只能给到
|
||
/// <c>EnemyAiFallbackAttacks</c>（金属吉他手那两下），这就是实机上看到的
|
||
/// 「只有远程射击动作、也没有武器、打不出伤害」。
|
||
/// 正解 = <c>SyncAgentCompanionAI</c> + <c>SyncCompanionMaster</c> + <b>模板自带的阵营</b>
|
||
/// （<c>UnitCamp.PlayerDefault = 1</c>，见 CompanionBind.cs），然后让客户端那棵树自己跑。
|
||
///
|
||
/// ⛑⛑ 2026-10-01 更早的实机：<b>只推 SyncCompanionMaster / SyncAgentCompanionAI 是不够的</b> ——
|
||
/// 那两个包只登记「谁是谁的随从」，客户端不会因此给它下任何指令，实测就是站着不动的木桩。
|
||
/// 当时补的就是这条用主线<b>本来就有</b>的敌人战斗指令驱动：
|
||
/// <c>SyncBattleAiS</c>(68555063) 开/关战斗 AI
|
||
/// <c>SyncUnitLockTarget</c>(68009754) 锁定谁
|
||
/// <c>SyncEnemyFightEdict</c>(68882858) 给不给攻击令牌
|
||
/// <c>SyncEnemyBattleMoveTowardUnit</c>(68792181) 朝谁移动
|
||
/// 这四个包在 <c>GameRouter.EnemyAiActions.cs:446-454</c> 已经在用（驱动敌人追玩家）。
|
||
/// 捐赠端 7k v0.5-2 那 323 行 <c>GarmCompanionAi.cs</c> 的核心也就是这行 ——
|
||
/// 所以它不需要整体移植，主线把同样的包换个目标发就行。
|
||
///
|
||
/// <b>跟随</b> = 没有敌人时把 target 留空、移动目标填主人 uid；
|
||
/// <b>协战</b> = 选一个最近的敌人当 target，同时给攻击令牌。
|
||
/// </summary>
|
||
internal sealed partial class GameRouter
|
||
{
|
||
private const int CompanionTickMs = 800;
|
||
|
||
/// <summary>每几条移动命令打一行日志（诊断"一步一停"用，别刷屏）。</summary>
|
||
private const int CompanionMoveLogEvery = 5;
|
||
|
||
/// <summary>随从离玩家多远之内才去找敌人打（米）。</summary>
|
||
private const float CompanionAggroMeters = 24f;
|
||
|
||
/// <summary>超过这个距离就放弃当前目标（米）。大于上面的进入值 ⇒ 滞回。</summary>
|
||
private const float CompanionDropMeters = 30f;
|
||
|
||
/// <summary>跟随时的停步距离（米）。捐赠端同款逻辑用的是 4f。</summary>
|
||
private const float CompanionFollowStopMeters = 4f;
|
||
|
||
/// <summary>worker 最长活多久（兜底，防止漏 stop 之后线程越积越多）。</summary>
|
||
private const long CompanionMaxLifetimeMs = 15 * 60 * 1000;
|
||
|
||
private sealed class CompanionAssistRuntime
|
||
{
|
||
public ulong UnitId;
|
||
public ulong OwnerUnitId;
|
||
|
||
/// <summary>
|
||
/// 当前锁定的目标。<b>初值必须是哨兵</b>（不是 0）：engagement 三件套只在目标变化时下发，
|
||
/// 而"跟随"态的目标正是 0 —— 若初值也是 0，<c>next != Target</c> 恒为 false ⇒
|
||
/// 整局<b>一个 engagement 包都发不出去</b>，包括"关掉战斗 AI"那条，随从就一直保持
|
||
/// spawn 时的战斗姿态举着枪（2026-10-01 实机踩到）。
|
||
/// </summary>
|
||
public ulong Target = ulong.MaxValue;
|
||
/// <summary>单调递增的 move 序号；契约里 MoveId/InstanceId 是 <c>byte</c>，落盘前截断。</summary>
|
||
public uint MoveSeq;
|
||
public long NextMoveAt;
|
||
|
||
/// <summary>
|
||
/// 估算锚点。服务端拿不到实体真实坐标（客户端不回传），只能这么估。
|
||
/// spawn 用的是「全 0 pose = 落在玩家跟前」的约定 ⇒ 首帧拿玩家坐标当起点是准的。
|
||
/// </summary>
|
||
public Vec3 Anchor;
|
||
public bool HasAnchor;
|
||
public int MoveCount;
|
||
|
||
/// <summary>朝向（度）。出招前先转身用 —— 官方技能很多带 NoRotation=true。</summary>
|
||
public float Facing;
|
||
/// <summary>出招冷却到期时间（TickCount64）。</summary>
|
||
public long CastUntil;
|
||
/// <summary>下次允许出招的时间。</summary>
|
||
public long ActionAt;
|
||
/// <summary>出招实例号；契约里 instanceId 是 <c>int</c>，别写成 uint。</summary>
|
||
public int CastInstance;
|
||
public int CastCount;
|
||
}
|
||
|
||
/// <summary>同一个单位只起一个 worker；uid 是 key。</summary>
|
||
private static readonly ConcurrentDictionary<ulong, byte> s_companionWorkers = new();
|
||
|
||
/// <summary>
|
||
/// 随从的<b>真实坐标</b>（uid → 位置/时刻）。由 <c>OnMovementReport</c> 从客户端上报流里喂进来。
|
||
///
|
||
/// ⛑⛑ 2026-10-01 实机定案：没有它，服务端只能用"首帧玩家坐标 + 每次移动推进"的估算锚点，
|
||
/// 误差几秒内就发散（日志里 flat 在 4.0/5.1/8.2 之间乱跳就是证据）⇒ 判定"贴脸了"时
|
||
/// 随从真实位置可能还在四五米外，对着空气挥拳 ⇒ **出招了但零命中上报**。
|
||
/// 捐赠端 <c>GarmCompanionAi.cs</c> 的 <c>TrackGarmMovement</c> 也是靠这条上报流拿随从坐标的。
|
||
/// </summary>
|
||
private static readonly ConcurrentDictionary<ulong, (Vec3 Pos, long AtTicks)> s_companionPositions = new();
|
||
|
||
/// <summary>随从坐标新鲜多久之内算可用（毫秒）。超时就退回估算，免得拿几秒前的旧点当真。</summary>
|
||
private const long CompanionPositionFreshMs = 3000;
|
||
|
||
/// <summary>由 <c>OnMovementReport</c> 调用：喂一条随从的真实坐标。</summary>
|
||
internal static void NoteCompanionPosition(ulong uid, Vec3 pos)
|
||
{
|
||
var first = !s_companionPositions.ContainsKey(uid);
|
||
s_companionPositions[uid] = (pos, Environment.TickCount64);
|
||
if (first)
|
||
GameAdminBridge.RequirePlayerSession()?.Session.Log.Info(
|
||
$"[COMPANION] position feed online uid={uid} at=({pos.X:F1},{pos.Y:F1},{pos.Z:F1}) " +
|
||
"— 出招距离判定改用真实坐标");
|
||
}
|
||
|
||
/// <summary>取随从的真实坐标；没有或过期返回 false。</summary>
|
||
private static bool TryGetCompanionPosition(ulong uid, out Vec3 pos)
|
||
{
|
||
pos = default;
|
||
if (!s_companionPositions.TryGetValue(uid, out var entry)) return false;
|
||
if (Environment.TickCount64 - entry.AtTicks > CompanionPositionFreshMs) return false;
|
||
pos = entry.Pos;
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 给刚绑好的随从起一个驱动 worker。失败不影响随从本身（它已经生成了）。
|
||
/// </summary>
|
||
internal static void StartCompanionAssist(ulong uid, ulong ownerUnitId)
|
||
{
|
||
if (uid == 0 || ownerUnitId == 0) return;
|
||
if (!s_companionWorkers.TryAdd(uid, 0)) return;
|
||
_ = Task.Run(() => RunCompanionAssistAsync(uid, ownerUnitId));
|
||
}
|
||
|
||
/// <summary>让某个随从停手（解散 / 单位消失时用）。</summary>
|
||
internal static void StopCompanionAssist(ulong uid)
|
||
=> s_companionWorkers.TryRemove(uid, out _);
|
||
|
||
private static async Task RunCompanionAssistAsync(ulong uid, ulong ownerUnitId)
|
||
{
|
||
var runtime = new CompanionAssistRuntime { UnitId = uid, OwnerUnitId = ownerUnitId };
|
||
var started = Environment.TickCount64;
|
||
try
|
||
{
|
||
var target = GameAdminBridge.RequirePlayerSession();
|
||
if (target is null) return;
|
||
var session = target.Value.Session;
|
||
|
||
for (var tick = 0; ; tick++)
|
||
{
|
||
await Task.Delay(CompanionTickMs).ConfigureAwait(false);
|
||
|
||
// 会话断了 / worker 被取消 / 活太久 ⇒ 收工
|
||
if (session.Client is not { Connected: true }) return;
|
||
if (!s_companionWorkers.ContainsKey(uid)) return;
|
||
if (Environment.TickCount64 - started > CompanionMaxLifetimeMs) return;
|
||
|
||
var world = GetStateIfExists(session);
|
||
if (world is null || !world.Ready) continue;
|
||
if (world.ActiveSpiritUnitId != ownerUnitId) continue; // 切角色/切场景，先按住
|
||
|
||
await TickCompanionAssistAsync(session, world, runtime, tick).ConfigureAwait(false);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
GameAdminBridge.RequirePlayerSession()?.Session.Log.Warn(
|
||
$"[COMPANION] assist worker stopped uid={uid}: {ex.Message}");
|
||
}
|
||
finally
|
||
{
|
||
s_companionWorkers.TryRemove(uid, out _);
|
||
}
|
||
}
|
||
|
||
private static async Task TickCompanionAssistAsync(TcpSession session, WorldEntryState world,
|
||
CompanionAssistRuntime rt, int tick)
|
||
{
|
||
var now = Environment.TickCount64;
|
||
|
||
// ---------- 0. 锚点：优先用客户端上报的<b>真实坐标</b>，拿不到才用估算 ----------
|
||
// ⛑⛑ 估算锚点几秒内就发散（实测 flat 乱跳）⇒ 出招判定全靠它必然打空。
|
||
// 有了上报流就直接用真值，估算只当兜底。
|
||
if (TryGetCompanionPosition(rt.UnitId, out var realPos))
|
||
{
|
||
rt.Anchor = realPos;
|
||
rt.HasAnchor = true;
|
||
}
|
||
else if (!rt.HasAnchor)
|
||
{
|
||
if (!world.HasLastReportedPlayerTransform) return;
|
||
rt.Anchor = world.LastReportedPlayerPosition;
|
||
rt.HasAnchor = true;
|
||
}
|
||
|
||
// ---------- 1. 选目标：最近的活敌人；没有就 0（= 跟随玩家） ----------
|
||
var (next, dest) = SelectCompanionTarget(session, world, rt);
|
||
|
||
// ⛑⛑ engagement 三件套<b>只在目标真的变了才发</b>。
|
||
// 原来每 6 个 tick 无条件重发一次 —— 主线注释（EnemyAiActions.cs:411-416 与
|
||
// EnemyAiAggroExitMeters 那段）已经把这坑写死了：每次重发都会重置客户端动作层、
|
||
// 裁断刚起步的动画，实测就是「走一步就僵住」。这是"一步一停"的第一来源。
|
||
if (next != rt.Target)
|
||
{
|
||
rt.Target = next;
|
||
// ⛑ 捐赠端也是这四个包一起发的；BattleAiS=true 是「会动」的前提。
|
||
await session.NotifyAsync(MethodId.SyncUnitLockTarget,
|
||
UxSerializer.Serialize(new SceneMethods.SyncUnitLockTarget { entityId = rt.UnitId, targetId = next }),
|
||
CancellationToken.None).ConfigureAwait(false);
|
||
await session.NotifyAsync(MethodId.SyncEnemyFightEdict,
|
||
UxSerializer.Serialize(new SceneMethods.SyncEnemyFightEdict { uid = rt.UnitId, isGive = next != 0 }),
|
||
CancellationToken.None).ConfigureAwait(false);
|
||
// ⛑ 跟随（没敌人）时**关掉**战斗 AI —— 否则它会一直保持举枪的战斗姿态慢慢挪。
|
||
// 主线驱动敌人就是这么写的（EnemyAiActions.cs:453 `value = target != 0`）。
|
||
var battleAi = next != 0 || PrivateServerConfigStore.Current.Gameplay.Aether.CompanionBattleAiWhenFollowing;
|
||
await session.NotifyAsync(MethodId.SyncBattleAiS,
|
||
UxSerializer.Serialize(new SceneMethods.SyncBattleAiS { agentId = rt.UnitId, value = battleAi }),
|
||
CancellationToken.None).ConfigureAwait(false);
|
||
session.Log.Info($"[COMPANION] goal unit={rt.UnitId} master={rt.OwnerUnitId} " +
|
||
$"target={next} mode={(next == 0 ? "follow" : "assist")} battleAi={battleAi}");
|
||
}
|
||
|
||
if (now < rt.NextMoveAt) return;
|
||
|
||
if (dest is null)
|
||
{
|
||
rt.NextMoveAt = now + 250;
|
||
return;
|
||
}
|
||
|
||
// ---------- 2. 位移量：按剩余距离反算，一条命令走完剩下的路 ----------
|
||
//
|
||
// ⛑⛑ "一步一停"的第二来源：SyncEnemyBattleMoveTowardUnit 是<b>有限位移</b> ——
|
||
// 客户端只走 MoveTime 秒就停下等下一条（EnemyAiActions.cs:54-68 那段写得很清楚：
|
||
// "走 0.65s、干站 0.35s，看起来就是一步一顿"）。原来的版本连 MoveTime 都没填，
|
||
// 等于让客户端走一个默认值、然后干等下一个 tick。
|
||
// ⇒ 这里完整复用主线调好的那一套：MoveTime + MinMoveTime(0.9×) + ReportOnStop，
|
||
// useSeconds 按剩余距离反算，命令越少起停越少。
|
||
var p = dest.Value;
|
||
var dx = p.X - rt.Anchor.X;
|
||
var dz = p.Z - rt.Anchor.Z;
|
||
if (!float.IsFinite(dx) || !float.IsFinite(dz))
|
||
{
|
||
rt.NextMoveAt = now + 250;
|
||
return;
|
||
}
|
||
// 不隔着楼层走：等目标回到这一层。
|
||
if (MathF.Abs(p.Y - rt.Anchor.Y) > 2.5f)
|
||
{
|
||
rt.NextMoveAt = now + 500;
|
||
return;
|
||
}
|
||
|
||
var stopAt = next == 0 ? CompanionFollowStopMeters : EnemyAiAttackRangeMeters;
|
||
var flat = MathF.Sqrt(dx * dx + dz * dz);
|
||
if (flat <= stopAt)
|
||
{
|
||
// ---------- 3. 贴身了：出招（协战才有，跟随模式不打） ----------
|
||
// ⛑⛑ 上一版只发移动+engagement，**从没发过出招包** —— 实机上看到它"摆远程射击
|
||
// 姿势却打不出伤害"就是客户端自己在空放。想让它真的帮打，必须服务端下
|
||
// <c>SyncUseTargetSkill</c>：客户端播技能、自己判定命中，命中的伤害再由
|
||
// <c>TrackLocalEnemyHitAsync</c> 记账（它在 OnSkillHit 里排在 releaser 校验之前）。
|
||
if (next != 0)
|
||
await CastCompanionAsync(session, rt, dest.Value, now);
|
||
rt.NextMoveAt = now + 250;
|
||
return;
|
||
}
|
||
|
||
// ⛑ 协战用主线的短步长（给贴脸用的）；跟随要走十几米，步长太短就是"一顿一顿慢慢挪"，
|
||
// 所以跟随时把上限抬到 gameplay.aether.companionFollowMoveSeconds。
|
||
var moveSeconds = EnemyAiMoveSecondsNow();
|
||
if (next == 0)
|
||
moveSeconds = MathF.Max(moveSeconds,
|
||
Math.Clamp(PrivateServerConfigStore.Current.Gameplay.Aether.CompanionFollowMoveSeconds, 0.5f, 12f));
|
||
var needSeconds = (flat - stopAt) / EnemyAiMoveMetersPerSecond;
|
||
var useSeconds = Math.Clamp(needSeconds, 0.4f, moveSeconds);
|
||
var useStep = EnemyAiMoveStepNow(useSeconds);
|
||
rt.NextMoveAt = now + (int)(useSeconds * 1000f) + 50;
|
||
|
||
if (flat > useStep)
|
||
{
|
||
var k = useStep / flat;
|
||
rt.Anchor = new Vec3(rt.Anchor.X + dx * k, rt.Anchor.Y, rt.Anchor.Z + dz * k);
|
||
}
|
||
else
|
||
{
|
||
rt.Anchor = new Vec3(p.X, rt.Anchor.Y, p.Z);
|
||
}
|
||
|
||
var token = (byte)(++rt.MoveSeq);
|
||
if (token == 0) token = (byte)(++rt.MoveSeq);
|
||
rt.MoveCount++;
|
||
|
||
// ⛑ 跟随用 **Run(6)**，协战保持 WalkFront(2)：BattleMoveActionType 枚举
|
||
// （dump.cs:1913359: Unknown=0 / Idle=1 / WalkFront=2 / WalkBack=3 / WalkLeft=4 /
|
||
// WalkRight=5 / **Run=6**）。我们一直用的是 WalkFront ⇒ 跟十几米全靠走，看着就是"慢慢挪"。
|
||
var action = (byte)2; // WalkFront
|
||
if (next == 0 && PrivateServerConfigStore.Current.Gameplay.Aether.CompanionRunWhenFollowing)
|
||
action = 6; // Run
|
||
|
||
await session.NotifyAsync(MethodId.SyncEnemyBattleMoveTowardUnit,
|
||
UxSerializer.Serialize(new SceneMethods.EnemyAiMoveTowardUnit4229938
|
||
{
|
||
EntityId = rt.UnitId,
|
||
TargetId = next != 0 ? next : rt.OwnerUnitId,
|
||
BattleMoveActionType = action,
|
||
MoveId = token,
|
||
InstanceId = token,
|
||
MoveTime = useSeconds,
|
||
// 略短于 MoveTime：客户端"至少走这么久"，防止它提前刹车收脚。
|
||
MinMoveTime = MathF.Max(0.1f, useSeconds * 0.9f),
|
||
ReportOnStop = true,
|
||
}), CancellationToken.None).ConfigureAwait(false);
|
||
|
||
if (rt.MoveCount <= 2 || rt.MoveCount % CompanionMoveLogEvery == 0)
|
||
session.Log.Info($"[COMPANION] move unit={rt.UnitId} toward={(next == 0 ? rt.OwnerUnitId : next)} " +
|
||
$"flat={flat:F1}m duration={useSeconds:F2}s gap={rt.NextMoveAt - now}ms " +
|
||
$"action={(action == 6 ? "Run" : "WalkFront")} count={rt.MoveCount}");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 贴身出招：<c>SyncUnitSmoothFace</c> 转身 + <c>SyncUseTargetSkill</c> 放招。
|
||
/// 与主线 <c>GameRouter.EnemyAiActions.cs:592-668</c> 的那段逐行对齐（那套是调过的，别另写）。
|
||
///
|
||
/// ⛑ 技能池来自 <c>gameplay.aether.companionAttacks</c>：随从<b>没有</b>自己的攻击模组
|
||
/// （行为集里空），只能借通用池；换池子改配置即可，不用重编译。
|
||
/// </summary>
|
||
private static async Task CastCompanionAsync(TcpSession session, CompanionAssistRuntime rt, Vec3 targetPos, long now)
|
||
{
|
||
if (now < rt.CastUntil || now < rt.ActionAt) return;
|
||
|
||
var pool = PrivateServerConfigStore.Current.Gameplay.Aether.CompanionAttacks;
|
||
if (pool is null || pool.Count == 0) return;
|
||
var skill = pool[rt.CastCount % pool.Count];
|
||
|
||
var dx = targetPos.X - rt.Anchor.X;
|
||
var dz = targetPos.Z - rt.Anchor.Z;
|
||
var facing = MathF.Atan2(dx, dz) * (180f / MathF.PI);
|
||
var deltaAngle = (facing - rt.Facing) % 360f;
|
||
if (deltaAngle > 180f) deltaAngle -= 360f;
|
||
if (deltaAngle < -180f) deltaAngle += 360f;
|
||
|
||
rt.CastInstance = rt.CastInstance == int.MaxValue ? 1 : rt.CastInstance + 1;
|
||
var moveId = (byte)(++rt.MoveSeq);
|
||
if (moveId == 0) moveId = (byte)(++rt.MoveSeq);
|
||
|
||
try
|
||
{
|
||
// ⛑ 走主线同一个 helper（和敌人共用开关）：默认发 SyncUnitSmoothFaceToTarget，
|
||
// 让客户端用真实朝向转向 —— 避免"转 90° 打空气"那种错题。
|
||
await TurnEnemyToAsync(session, rt.UnitId, rt.Target, new SceneMethods.EnemyAiFace4229938
|
||
{
|
||
pid = rt.UnitId,
|
||
fromAngle = rt.Facing,
|
||
changeAngle = deltaAngle,
|
||
});
|
||
|
||
await session.NotifyAsync(MethodId.SyncUseTargetSkill,
|
||
UxSerializer.Serialize(new SceneMethods.EnemyAiSkillParam4229938
|
||
{
|
||
entityId = rt.UnitId,
|
||
targetId = rt.Target,
|
||
moveId = moveId,
|
||
instanceId = rt.CastInstance,
|
||
skillId = skill,
|
||
rotate = facing,
|
||
unitPosition = new SceneMethods.UxVector3(rt.Anchor.X, rt.Anchor.Y, rt.Anchor.Z),
|
||
location = new SceneMethods.UxVector3(targetPos.X, targetPos.Y, targetPos.Z),
|
||
faceToPos = new SceneMethods.UxVector3(targetPos.X, targetPos.Y, targetPos.Z),
|
||
SelfMobilityPos = new SceneMethods.UxVector3(rt.Anchor.X, rt.Anchor.Y, rt.Anchor.Z),
|
||
TarMobilityPos = new SceneMethods.UxVector3(targetPos.X, targetPos.Y, targetPos.Z),
|
||
}), CancellationToken.None).ConfigureAwait(false);
|
||
|
||
rt.Facing = facing;
|
||
rt.CastUntil = now + EnemyAiCastBusyMsNow();
|
||
rt.ActionAt = now + EnemyAiCastIntervalMsNow();
|
||
if (++rt.CastCount <= 2 || rt.CastCount % 5 == 0)
|
||
session.Log.Info($"[COMPANION] cast unit={rt.UnitId} target={rt.Target} skill={skill} " +
|
||
$"count={rt.CastCount} method=SyncUseTargetSkill " +
|
||
"(伤害由 TrackLocalEnemyHitAsync 记账；看到 [HIT] reject releaser=<随从uid> 即命中)");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
session.Log.Warn($"[COMPANION] cast failed unit={rt.UnitId}: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从主线的本地敌人账本里挑一个最近的目标，并返回它当前的位置。挑不到返回 (0, 玩家坐标) = 跟随。
|
||
/// ⛑ 排除：自己、玩家单位、已死单位；是否参战按<b>离玩家的距离</b>判断（随从离玩家太远就不打）。
|
||
/// </summary>
|
||
private static (ulong Uid, Vec3? Position) SelectCompanionTarget(
|
||
TcpSession session, WorldEntryState world, CompanionAssistRuntime rt)
|
||
{
|
||
if (!world.HasLastReportedPlayerTransform) return (0, null);
|
||
var player = world.LastReportedPlayerPosition;
|
||
|
||
var ledger = GetLocalEnemyRuntimeState(session);
|
||
ulong best = 0;
|
||
var bestDistance = float.MaxValue;
|
||
Vec3? bestPos = null;
|
||
|
||
lock (ledger.SyncRoot)
|
||
{
|
||
foreach (var enemy in ledger.Enemies.Values)
|
||
{
|
||
if (enemy.Dead || enemy.Uid == rt.UnitId || enemy.Uid == rt.OwnerUnitId
|
||
|| enemy.Uid == world.ActiveSpiritUnitId) continue;
|
||
var toPlayer = DistanceSq(enemy.Position, player);
|
||
if (toPlayer > CompanionAggroMeters * CompanionAggroMeters) continue;
|
||
if (toPlayer >= bestDistance) continue;
|
||
bestDistance = toPlayer;
|
||
best = enemy.Uid;
|
||
// 服务端刷出来的用估算位（AI推进），客户端刷的只有命中点。
|
||
bestPos = enemy.ServerSpawned ? enemy.AiPosition : enemy.Position;
|
||
}
|
||
}
|
||
|
||
// 已咬住的目标用更大的脱离半径（滞回），否则在边界上会反复切目标 ——
|
||
// 每切一次都要重发 engagement 三件套，动作层被重置，就是"一步一停"的第一来源。
|
||
if (rt.Target != 0 && ledger.Enemies.TryGetValue(rt.Target, out var current)
|
||
&& !current.Dead && DistanceSq(current.Position, player) <= CompanionDropMeters * CompanionDropMeters)
|
||
return (rt.Target, current.ServerSpawned ? current.AiPosition : current.Position);
|
||
|
||
if (best != 0) return (best, bestPos);
|
||
|
||
// 没有敌人 ⇒ 跟随玩家
|
||
return (0, player);
|
||
}
|
||
|
||
private static float DistanceSq(Vec3 a, Vec3 b)
|
||
{
|
||
var x = a.X - b.X; var y = a.Y - b.Y; var z = a.Z - b.Z;
|
||
var d = x * x + y * y + z * z;
|
||
return float.IsFinite(d) ? d : float.PositiveInfinity;
|
||
}
|
||
}
|