kronic
bd8458853b
Player-built structures now physically block enemies (husks walked straight through walls before). Dedicated "Structure" physics layer (slot 9) so the player passes its own walls while enemies are stopped: - New WorldCollisionConfig.StructureMask, baked from the "Structure" layer in WorldCollisionAuthoring (mirrors EnvironmentMask). EnemyAISystem ORs it into the movement sweep filter (CollidesWith = envMask | structMask) — no new system, same 1-2 SphereCasts per enemy. - Wall/Turret/Pylon prefabs get a cell-sized BoxCollider on the Structure layer (Wall's existing one relayered). - Physics matrix: Default x Structure unchecked, so the kinematic player CC (Default) passes its own walls while the enemy's explicit cast still hits them. Despawn frees collision for free (collider dies with the entity). Play-verified baked filters: StructMask=512; structure colliders BelongsTo=512, CollidesWith=0xFFFFFFFE (includes Environment for the enemy cast, EXCLUDES bit 0 so the player passes). 389/389 EditMode, no exceptions. Server-only/static colliders -> deterministic, no client divergence. SaveData stays v5. Phase C complete (C5-C7). A visual fun-gate (husk stops at wall, player walks through) is the operator's eyes. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
509 lines
30 KiB
C#
509 lines
30 KiB
C#
using ProjectM.Simulation;
|
|
using Unity.Burst;
|
|
using Unity.Collections;
|
|
using Unity.Entities;
|
|
using Unity.Mathematics;
|
|
using Unity.NetCode;
|
|
using Unity.Physics;
|
|
using Unity.Transforms;
|
|
|
|
namespace ProjectM.Server
|
|
{
|
|
/// <summary>
|
|
/// Server-authoritative Husk AI: each tick every Husk seeks the nearest LIVING player and strikes on
|
|
/// contact. Husks are OWNERLESS INTERPOLATED ghosts (not predicted), so this runs SERVER-ONLY in the plain
|
|
/// <see cref="SimulationSystemGroup"/> — writing <see cref="LocalTransform"/> directly (replicated to clients
|
|
/// by the stock LocalTransform default variant; no hand-written <c>[GhostField]</c>). Ordered
|
|
/// <c>[UpdateAfter(PredictedSimulationSystemGroup)]</c> (the predicted group is OrderFirst, so UpdateBefore is ignored) so a contact <see cref="DamageEvent"/> appended this
|
|
/// tick is drained the following tick by <see cref="HealthApplyDamageSystem"/> (which runs inside the predicted
|
|
/// group on the server). No <c>Simulate</c> filter: interpolated ghosts are not predicted and the server has
|
|
/// no rollback, so every Husk advances exactly once per tick. Movement/attack math is the pure, deterministic
|
|
/// <see cref="EnemyAIMath"/>; server fixed-step <c>SystemAPI.Time.DeltaTime</c> is correct here (not the
|
|
/// rollback loop). Structural-free: the only deferred op is appending to the player's DamageEvent buffer.
|
|
/// </summary>
|
|
[BurstCompile]
|
|
[WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
|
|
[UpdateInGroup(typeof(SimulationSystemGroup))]
|
|
[UpdateAfter(typeof(PredictedSimulationSystemGroup))]
|
|
public partial struct EnemyAISystem : ISystem
|
|
{
|
|
EntityQuery m_EnemyProjectiles;
|
|
|
|
[BurstCompile]
|
|
public void OnCreate(ref SystemState state)
|
|
{
|
|
state.RequireForUpdate<NetworkTime>();
|
|
state.RequireForUpdate(state.GetEntityQuery(ComponentType.ReadOnly<EnemyTag>()));
|
|
m_EnemyProjectiles = state.GetEntityQuery(ComponentType.ReadOnly<EnemyProjectile>());
|
|
}
|
|
|
|
[BurstCompile]
|
|
public void OnUpdate(ref SystemState state)
|
|
{
|
|
// Snapshot living player targets once this tick (stable query order).
|
|
var playerEntities = new NativeList<Entity>(Allocator.Temp);
|
|
var playerPositions = new NativeList<float3>(Allocator.Temp);
|
|
var playerRegions = new NativeList<byte>(Allocator.Temp);
|
|
foreach (var (xform, health, region, entity) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>, RefRO<RegionTag>>()
|
|
.WithAll<PlayerTag>()
|
|
.WithEntityAccess())
|
|
{
|
|
if (health.ValueRO.Current <= 0f)
|
|
continue; // don't chase or strike a corpse
|
|
playerEntities.Add(entity);
|
|
playerPositions.Add(xform.ValueRO.Position);
|
|
playerRegions.Add(region.ValueRO.Region);
|
|
}
|
|
|
|
// EB-1 fortress aggro: also snapshot live structures (Turret/Wall/Pylon carry Health; automation
|
|
// machines lack it so the query excludes them). Snapshot ABOVE the early-return so Husks keep razing
|
|
// the base even with every player dead/away (the locked 'push for structures' fork).
|
|
var structureEntities = new NativeList<Entity>(Allocator.Temp);
|
|
var structurePositions = new NativeList<float3>(Allocator.Temp);
|
|
var structureRegions = new NativeList<byte>(Allocator.Temp);
|
|
foreach (var (sx, sh, sr, se) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>, RefRO<RegionTag>>()
|
|
.WithAll<PlacedStructure>()
|
|
.WithEntityAccess())
|
|
{
|
|
if (sh.ValueRO.Current <= 0f)
|
|
continue; // skip a structure already at 0 (pending destroy this tick)
|
|
structureEntities.Add(se);
|
|
structurePositions.Add(sx.ValueRO.Position);
|
|
structureRegions.Add(sr.ValueRO.Region);
|
|
}
|
|
|
|
// END-1: the Engine Core is a FALLBACK target. When no living player/structure remains, undefended
|
|
// Husks march on the base heart (PlotCenter) so the base can be overrun instead of the swarm idling.
|
|
bool coreAlive = SystemAPI.HasSingleton<BaseAnchor>()
|
|
&& SystemAPI.TryGetSingleton<CoreIntegrity>(out var coreInteg) && coreInteg.Current > 0;
|
|
float3 corePos = coreAlive ? BaseGridMath.PlotCenter(SystemAPI.GetSingleton<BaseAnchor>()) : float3.zero;
|
|
|
|
if (playerEntities.Length == 0 && structureEntities.Length == 0 && !coreAlive)
|
|
{
|
|
playerEntities.Dispose();
|
|
playerPositions.Dispose();
|
|
playerRegions.Dispose();
|
|
structureEntities.Dispose();
|
|
structurePositions.Dispose();
|
|
structureRegions.Dispose();
|
|
return;
|
|
}
|
|
|
|
float dt = SystemAPI.Time.DeltaTime;
|
|
var serverTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
|
|
uint now = serverTick.TickIndexForValidTick;
|
|
// Live feel knobs (MC-0): one read, guarded at use. Server-only — clients never simulate enemies.
|
|
var tune = SystemAPI.TryGetSingleton<TuningConfig>(out var tcfg) ? tcfg : TuningConfig.Defaults();
|
|
float structAggro = math.max(0f, tune.StructureAggroWeight);
|
|
var ecb = new EntityCommandBuffer(Allocator.Temp);
|
|
bool havePhysics = SystemAPI.TryGetSingleton<PhysicsWorldSingleton>(out var physics);
|
|
uint envMask = SystemAPI.TryGetSingleton<WorldCollisionConfig>(out var worldCol) ? worldCol.EnvironmentMask : 0u;
|
|
uint sweepMask = envMask | worldCol.StructureMask; // DR-042 C5: also collide enemies against player-built walls
|
|
var envFilter = new CollisionFilter { BelongsTo = ~0u, CollidesWith = sweepMask, GroupIndex = 0 };
|
|
bool sweep = havePhysics && sweepMask != 0u;
|
|
const float SweepRadius = 0.5f; // collide-and-slide sphere radius for Husk movement
|
|
|
|
foreach (var (xform, stats, cooldown, knockback, windup, region) in
|
|
SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRW<EnemyAttackCooldown>,
|
|
RefRW<KnockbackState>, RefRW<AttackWindup>, RefRO<RegionTag>>()
|
|
.WithAll<EnemyTag>().WithNone<LungeState, SpitterState>())
|
|
{
|
|
float3 pos = xform.ValueRO.Position;
|
|
byte huskRegion = region.ValueRO.Region;
|
|
bool huskCoreAlive = coreAlive && huskRegion == RegionId.Base;
|
|
|
|
// Knockback overrides seek/strike for its window — EnemyAISystem stays the SOLE writer of Position.
|
|
var kb = knockback.ValueRO;
|
|
if (kb.UntilTick != 0)
|
|
{
|
|
var kbTick = new NetworkTick(kb.UntilTick);
|
|
if (kbTick.IsValid && kbTick.IsNewerThan(serverTick))
|
|
{
|
|
float3 kpos = pos + new float3(kb.Dir.x, 0f, kb.Dir.y) * (kb.Speed * dt);
|
|
kpos.y = pos.y;
|
|
if (sweep)
|
|
kpos = SweptMove(in physics, pos, kpos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = kpos;
|
|
windup.ValueRW.WindUpUntilTick = 0; // a recoiling Husk does not wind up
|
|
continue; // recoiling: skip seek + strike this tick
|
|
}
|
|
knockback.ValueRW.UntilTick = 0; // window elapsed
|
|
}
|
|
|
|
// EB-1 fortress aggro: nearest of players (weight 1) + structures (StructureAggroWeight) — a wall/
|
|
// turret is the preferred target unless a player is in the way (closer after weighting).
|
|
EnemyAIMath.PickWeightedNearest(pos, playerPositions, playerRegions, structurePositions, structureRegions, huskRegion, structAggro, out bool tgtIsStruct, out int tgtIdx);
|
|
if (tgtIdx < 0 && !huskCoreAlive)
|
|
continue; // no player/structure and no Core -> nothing to seek
|
|
Entity targetEntity = tgtIdx < 0 ? Entity.Null
|
|
: (tgtIsStruct ? structureEntities[tgtIdx] : playerEntities[tgtIdx]);
|
|
float3 targetPos = tgtIdx < 0 ? corePos
|
|
: (tgtIsStruct ? structurePositions[tgtIdx] : playerPositions[tgtIdx]);
|
|
|
|
// Seek: stop just inside strike range so the Husk holds position to attack.
|
|
float stopDistance = stats.ValueRO.AttackRange * 0.9f;
|
|
float3 vel = EnemyAIMath.SeekVelocity(pos, targetPos, stats.ValueRO.MoveSpeed, stopDistance);
|
|
float3 newPos = pos + vel * dt;
|
|
newPos.y = pos.y; // hold the movement plane
|
|
if (sweep)
|
|
newPos = SweptMove(in physics, pos, newPos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = newPos;
|
|
|
|
// Face the target (planar) for presentation.
|
|
float3 toTarget = targetPos - pos;
|
|
toTarget.y = 0f;
|
|
if (math.lengthsq(toTarget) > 1e-6f)
|
|
xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(toTarget), math.up());
|
|
|
|
// Two-phase strike with a telegraph wind-up: commit a wind-up when first in-range + cooldown-ready,
|
|
// then strike when it elapses. WindUpUntilTick is a [GhostField] so the client can cue the ~0.3s
|
|
// tell; leaving range mid-windup cancels it. Tuning.AttackWindupTicks = 0/1 -> near-instant (legacy).
|
|
bool inRange = EnemyAIMath.InAttackRange(pos, targetPos, stats.ValueRO.AttackRange);
|
|
uint windRaw = windup.ValueRO.WindUpUntilTick;
|
|
|
|
if (windRaw != 0)
|
|
{
|
|
if (!inRange)
|
|
{
|
|
windup.ValueRW.WindUpUntilTick = 0; // target left range -> cancel the wind-up
|
|
}
|
|
else
|
|
{
|
|
var windTick = new NetworkTick(windRaw);
|
|
if (!(windTick.IsValid && windTick.IsNewerThan(serverTick)))
|
|
{
|
|
if (targetEntity != Entity.Null) ecb.AppendToBuffer(targetEntity, new DamageEvent
|
|
{
|
|
Amount = stats.ValueRO.AttackDamage,
|
|
SourceNetworkId = -1, // environment / Husk, not a player
|
|
SourceTick = TickUtil.NonZero(now),
|
|
});
|
|
uint cooldownTicks = (uint)math.max(1, stats.ValueRO.AttackCooldownTicks);
|
|
cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + cooldownTicks);
|
|
windup.ValueRW.WindUpUntilTick = 0;
|
|
}
|
|
}
|
|
}
|
|
else if (inRange)
|
|
{
|
|
uint nextRaw = cooldown.ValueRO.NextAttackTick;
|
|
bool ready = true;
|
|
if (nextRaw != 0)
|
|
{
|
|
var nextTick = new NetworkTick(nextRaw);
|
|
if (nextTick.IsValid && nextTick.IsNewerThan(serverTick))
|
|
ready = false;
|
|
}
|
|
if (ready)
|
|
{
|
|
uint windupTicks = (uint)math.max(1f, tune.GruntWindupTicks);
|
|
windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + windupTicks);
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Charger pass: a Husk variant baked with LungeState commits to a punishable fixed-direction lunge.
|
|
// Component-presence is the discriminator; the Grunt pass above excludes these via .WithNone<LungeState>().
|
|
// Charger feel knobs — live-tunable via TuningConfig (MC-0), guarded at the read site. Server-only
|
|
// (clients never simulate Chargers); the >=1-tick floor avoids a degenerate instant/no-travel lunge.
|
|
float ChargerLungeSpeed = math.max(0f, tune.ChargerLungeSpeed); // units/s while lunging
|
|
uint ChargerLungeDurationTicks = (uint)math.max(1f, tune.ChargerLungeDurationTicks); // committed travel
|
|
uint ChargerWindupTicks = (uint)math.max(1f, tune.ChargerWindupTicks); // readable telegraph lead
|
|
uint ChargerWhiffStaggerTicks = (uint)math.max(1f, tune.ChargerWhiffStaggerTicks); // punish window
|
|
uint chargerWhiffsThisTick = 0;
|
|
foreach (var (xform, stats, cooldown, knockback, windup, lunge, region) in
|
|
SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRW<EnemyAttackCooldown>,
|
|
RefRW<KnockbackState>, RefRW<AttackWindup>, RefRW<LungeState>, RefRO<RegionTag>>()
|
|
.WithAll<EnemyTag>().WithNone<SpitterState>())
|
|
{
|
|
float3 pos = xform.ValueRO.Position;
|
|
byte cHuskRegion = region.ValueRO.Region;
|
|
bool cHuskCoreAlive = coreAlive && cHuskRegion == RegionId.Base;
|
|
|
|
// 1. Knockback wins (and cancels any in-flight lunge so Position keeps a single writer).
|
|
var kb = knockback.ValueRO;
|
|
if (kb.UntilTick != 0)
|
|
{
|
|
var kbTick = new NetworkTick(kb.UntilTick);
|
|
if (kbTick.IsValid && kbTick.IsNewerThan(serverTick))
|
|
{
|
|
float3 kpos = pos + new float3(kb.Dir.x, 0f, kb.Dir.y) * (kb.Speed * dt);
|
|
kpos.y = pos.y;
|
|
if (sweep) kpos = SweptMove(in physics, pos, kpos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = kpos;
|
|
windup.ValueRW.WindUpUntilTick = 0;
|
|
lunge.ValueRW.UntilTick = 0;
|
|
continue;
|
|
}
|
|
knockback.ValueRW.UntilTick = 0;
|
|
}
|
|
|
|
// EB-1 fortress aggro: same weighted target selection as the Grunt pass (shared helper).
|
|
EnemyAIMath.PickWeightedNearest(pos, playerPositions, playerRegions, structurePositions, structureRegions, cHuskRegion, structAggro, out bool cIsStruct, out int cIdx);
|
|
if (cIdx < 0 && !cHuskCoreAlive)
|
|
continue;
|
|
Entity cTargetEntity = cIdx < 0 ? Entity.Null
|
|
: (cIsStruct ? structureEntities[cIdx] : playerEntities[cIdx]);
|
|
float3 cTargetPos = cIdx < 0 ? corePos
|
|
: (cIsStruct ? structurePositions[cIdx] : playerPositions[cIdx]);
|
|
|
|
// 2. Lunge active: travel the locked direction; damage on contact, or stagger on a wall-stop whiff.
|
|
var lg = lunge.ValueRO;
|
|
if (lg.UntilTick != 0)
|
|
{
|
|
var lgTick = new NetworkTick(lg.UntilTick);
|
|
if (lgTick.IsValid && lgTick.IsNewerThan(serverTick))
|
|
{
|
|
float3 intended = pos + new float3(lg.Dir.x, 0f, lg.Dir.y) * (lg.Speed * dt);
|
|
intended.y = pos.y;
|
|
float3 moved = sweep ? SweptMove(in physics, pos, intended, SweepRadius, envFilter) : intended;
|
|
xform.ValueRW.Position = moved;
|
|
if (math.lengthsq(lg.Dir) > 1e-6f)
|
|
xform.ValueRW.Rotation = quaternion.LookRotationSafe(new float3(lg.Dir.x, 0f, lg.Dir.y), math.up());
|
|
|
|
if (EnemyAIMath.InAttackRange(moved, cTargetPos, stats.ValueRO.AttackRange))
|
|
{
|
|
if (cTargetEntity != Entity.Null) ecb.AppendToBuffer(cTargetEntity, new DamageEvent
|
|
{
|
|
Amount = stats.ValueRO.AttackDamage,
|
|
SourceNetworkId = -1,
|
|
SourceTick = TickUtil.NonZero(now),
|
|
});
|
|
uint cdTicks = (uint)math.max(1, stats.ValueRO.AttackCooldownTicks);
|
|
cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + cdTicks);
|
|
lunge.ValueRW.UntilTick = 0; // landed -> end the lunge
|
|
}
|
|
else
|
|
{
|
|
float intendedDist = math.distance(pos.xz, intended.xz);
|
|
float actualDist = math.distance(pos.xz, moved.xz);
|
|
if (intendedDist > 1e-4f && actualDist < intendedDist * 0.5f)
|
|
{
|
|
cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks);
|
|
lunge.ValueRW.UntilTick = 0; // wall-stop whiff -> stagger (the punish window)
|
|
chargerWhiffsThisTick++;
|
|
lunge.ValueRW.StaggerUntilTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks); // scoreable punish window
|
|
}
|
|
}
|
|
continue; // committed this tick
|
|
}
|
|
|
|
// Timer elapsed without landing -> overshoot whiff -> stagger, then seek this tick.
|
|
cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks);
|
|
lunge.ValueRW.UntilTick = 0;
|
|
chargerWhiffsThisTick++;
|
|
lunge.ValueRW.StaggerUntilTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks); // scoreable punish window
|
|
}
|
|
|
|
// 3. Seek + face (shared shape with the Grunt path).
|
|
float cStop = stats.ValueRO.AttackRange * 0.9f;
|
|
float3 cvel = EnemyAIMath.SeekVelocity(pos, cTargetPos, stats.ValueRO.MoveSpeed, cStop);
|
|
float3 cNewPos = pos + cvel * dt; cNewPos.y = pos.y;
|
|
if (sweep) cNewPos = SweptMove(in physics, pos, cNewPos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = cNewPos;
|
|
float3 cToTarget = cTargetPos - pos; cToTarget.y = 0f;
|
|
if (math.lengthsq(cToTarget) > 1e-6f)
|
|
xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(cToTarget), math.up());
|
|
|
|
// 4. Commit: a wind-up elapses -> LOCK the lunge direction + fire. NO cancel-on-leave-range — the
|
|
// whole point is the commit lands even if the player dodged out of range (the punishable tell).
|
|
uint cWindRaw = windup.ValueRO.WindUpUntilTick;
|
|
if (cWindRaw != 0)
|
|
{
|
|
var cWindTick = new NetworkTick(cWindRaw);
|
|
if (!(cWindTick.IsValid && cWindTick.IsNewerThan(serverTick)))
|
|
{
|
|
float3 toT = cTargetPos - pos; toT.y = 0f;
|
|
float2 ldir = math.lengthsq(toT) > 1e-6f ? math.normalize(toT.xz) : new float2(0f, 1f);
|
|
lunge.ValueRW.Dir = ldir;
|
|
lunge.ValueRW.Speed = ChargerLungeSpeed;
|
|
lunge.ValueRW.UntilTick = TickUtil.NonZero(now + ChargerLungeDurationTicks);
|
|
windup.ValueRW.WindUpUntilTick = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool cInRange = EnemyAIMath.InAttackRange(pos, cTargetPos, stats.ValueRO.AttackRange);
|
|
if (cInRange)
|
|
{
|
|
bool cReady = cooldown.ValueRO.NextAttackTick == 0
|
|
|| !new NetworkTick(cooldown.ValueRO.NextAttackTick).IsNewerThan(serverTick);
|
|
if (cReady)
|
|
windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + ChargerWindupTicks);
|
|
}
|
|
}
|
|
}
|
|
// --- Spitter pass: a Husk variant baked with SpitterState holds a RANGED range-band and fires a
|
|
// telegraphed, dodgeable spit. Partitioned .WithAll<SpitterState>().WithNone<LungeState>() (and the Grunt
|
|
// pass excludes SpitterState) so a Spitter is moved by EXACTLY this pass — the sole-Position-writer rule.
|
|
bool haveSpit = SystemAPI.TryGetSingleton<SpitterProjectilePrefab>(out var spitCfg) && spitCfg.Prefab != Entity.Null;
|
|
int liveSpits = m_EnemyProjectiles.CalculateEntityCount();
|
|
LocalTransform spitBakedLt = default;
|
|
EnemyProjectile spitBakedProj = default;
|
|
if (haveSpit)
|
|
{
|
|
spitBakedLt = state.EntityManager.GetComponentData<LocalTransform>(spitCfg.Prefab);
|
|
spitBakedProj = state.EntityManager.GetComponentData<EnemyProjectile>(spitCfg.Prefab);
|
|
}
|
|
foreach (var (xform, stats, knockback, windup, spitter, region) in
|
|
SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRW<KnockbackState>,
|
|
RefRW<AttackWindup>, RefRW<SpitterState>, RefRO<RegionTag>>()
|
|
.WithAll<EnemyTag, SpitterState>().WithNone<LungeState>())
|
|
{
|
|
float3 pos = xform.ValueRO.Position;
|
|
byte sRegion = region.ValueRO.Region;
|
|
bool sCoreAlive = coreAlive && sRegion == RegionId.Base;
|
|
|
|
// 1. Knockback overrides everything (sole Position writer preserved).
|
|
var kb = knockback.ValueRO;
|
|
if (kb.UntilTick != 0)
|
|
{
|
|
var kbTick = new NetworkTick(kb.UntilTick);
|
|
if (kbTick.IsValid && kbTick.IsNewerThan(serverTick))
|
|
{
|
|
float3 kpos = pos + new float3(kb.Dir.x, 0f, kb.Dir.y) * (kb.Speed * dt);
|
|
kpos.y = pos.y;
|
|
if (sweep) kpos = SweptMove(in physics, pos, kpos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = kpos;
|
|
windup.ValueRW.WindUpUntilTick = 0;
|
|
continue;
|
|
}
|
|
knockback.ValueRW.UntilTick = 0;
|
|
}
|
|
|
|
// 2. Target (region-scoped shared helper); Core fallback like the Grunt/Charger passes.
|
|
EnemyAIMath.PickWeightedNearest(pos, playerPositions, playerRegions, structurePositions, structureRegions, sRegion, structAggro, out bool sIsStruct, out int sIdx);
|
|
if (sIdx < 0 && !sCoreAlive)
|
|
continue;
|
|
Entity sTargetEntity = sIdx < 0 ? Entity.Null
|
|
: (sIsStruct ? structureEntities[sIdx] : playerEntities[sIdx]);
|
|
float3 sTargetPos = sIdx < 0 ? corePos
|
|
: (sIsStruct ? structurePositions[sIdx] : playerPositions[sIdx]);
|
|
|
|
// 3. Range-band movement: advance if too far, retreat if too close, hold in-band. Face the target.
|
|
var sp = spitter.ValueRO;
|
|
float3 bandVel = EnemyAIMath.BandVelocity(pos, sTargetPos, stats.ValueRO.MoveSpeed, sp.PreferredRange, sp.RangeTolerance);
|
|
float3 sNewPos = pos + bandVel * dt; sNewPos.y = pos.y;
|
|
if (sweep) sNewPos = SweptMove(in physics, pos, sNewPos, SweepRadius, envFilter);
|
|
xform.ValueRW.Position = sNewPos;
|
|
float3 sToTarget = sTargetPos - pos; sToTarget.y = 0f;
|
|
if (math.lengthsq(sToTarget) > 1e-6f)
|
|
xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(sToTarget), math.up());
|
|
|
|
// 4. Telegraphed shot: commit a wind-up (the dodge window) when the shot gate is ready; on elapse,
|
|
// spawn a spit toward the target. A cornered Spitter still fires (point-blank) — no safe corner.
|
|
uint sWindRaw = windup.ValueRO.WindUpUntilTick;
|
|
if (sWindRaw != 0)
|
|
{
|
|
var sWindTick = new NetworkTick(sWindRaw);
|
|
if (!(sWindTick.IsValid && sWindTick.IsNewerThan(serverTick)))
|
|
{
|
|
float2 dir2 = math.lengthsq(sToTarget) > 1e-6f ? math.normalize(sToTarget.xz) : new float2(0f, 1f);
|
|
if (haveSpit && liveSpits < math.max(1, spitCfg.MaxLiveProjectiles))
|
|
{
|
|
float3 spawnPos = pos + new float3(dir2.x, 0f, dir2.y) * 0.8f;
|
|
spawnPos.y = pos.y;
|
|
var spit = ecb.Instantiate(spitCfg.Prefab);
|
|
ecb.SetComponent(spit, spitBakedLt.WithPosition(spawnPos)); // preserve baked [GhostField] Scale
|
|
ecb.SetComponent(spit, new EnemyProjectile
|
|
{
|
|
Direction = dir2,
|
|
Speed = sp.ProjectileSpeed,
|
|
Damage = stats.ValueRO.AttackDamage,
|
|
Range = spitBakedProj.Range,
|
|
DistanceTravelled = 0f,
|
|
LastStep = 0f,
|
|
Region = sRegion,
|
|
});
|
|
ecb.AddComponent(spit, new RegionTag { Region = sRegion }); // relevancy (the spit prefab bakes none)
|
|
liveSpits++;
|
|
uint shotCd = (uint)math.max(1, stats.ValueRO.AttackCooldownTicks);
|
|
spitter.ValueRW.NextShotTick = TickUtil.NonZero(now + shotCd);
|
|
}
|
|
else
|
|
{
|
|
// Over the concurrent cap (or no prefab wired): soft-fail — short retry, no full cooldown burn.
|
|
spitter.ValueRW.NextShotTick = TickUtil.NonZero(now + 8u);
|
|
}
|
|
windup.ValueRW.WindUpUntilTick = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool sReady = sp.NextShotTick == 0 || !new NetworkTick(sp.NextShotTick).IsNewerThan(serverTick);
|
|
// In-band gate (DR-041): telegraph + fire ONLY when holding the preferred band, OR when the target has
|
|
// closed inside CorneredRange (point-blank, no retreat room). While ADVANCING from too far OR
|
|
// RETREATING from a too-close target it must NOT fire — that IS the hold-range "reposition" question.
|
|
float sDist = math.length(sToTarget);
|
|
bool sInBand = math.abs(sDist - sp.PreferredRange) <= sp.RangeTolerance;
|
|
bool sCornered = sDist <= sp.CorneredRange;
|
|
if (sReady && (sInBand || sCornered) && (sTargetEntity != Entity.Null || sCoreAlive))
|
|
{
|
|
uint wTicks = (uint)math.max(1, sp.WindupTicks);
|
|
windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + wTicks);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Slice 1 (Feature D): derive the replicated IsLunging cue ONCE per tick from the end-of-tick LungeState
|
|
// (single point, idempotent — mirrors PlayerDeathStateSystem deriving Dead from Health). .WithPresent so a
|
|
// Charger whose bit is currently DISABLED is still visited (Entities default-excludes disabled enableables).
|
|
foreach (var (lunge, isLunging) in
|
|
SystemAPI.Query<RefRO<LungeState>, EnabledRefRW<IsLunging>>()
|
|
.WithAll<EnemyTag>().WithPresent<IsLunging>())
|
|
{
|
|
isLunging.ValueRW = lunge.ValueRO.UntilTick != 0u; // lunging iff a committed lunge is live this tick
|
|
}
|
|
|
|
if (chargerWhiffsThisTick != 0 && SystemAPI.HasSingleton<DevTelemetry>())
|
|
SystemAPI.GetSingletonRW<DevTelemetry>().ValueRW.ChargerWhiffWindowsOpened += chargerWhiffsThisTick;
|
|
|
|
ecb.Playback(state.EntityManager);
|
|
|
|
ecb.Dispose();
|
|
playerEntities.Dispose();
|
|
playerPositions.Dispose();
|
|
playerRegions.Dispose();
|
|
structureEntities.Dispose();
|
|
structurePositions.Dispose();
|
|
structureRegions.Dispose();
|
|
}
|
|
|
|
// Swept collide-and-slide for server-authoritative Husk movement: sphere-cast the intended step against
|
|
// the static environment (boundary ring + landmarks) and stop at / glance along the first wall hit. Closest-
|
|
// hit SphereCast is non-generic -> Burst-safe (CLAUDE.md generic-collector hazard avoided). Y is held flat.
|
|
static float3 SweptMove(in PhysicsWorldSingleton physics, float3 from, float3 to, float radius, CollisionFilter filter)
|
|
{
|
|
float3 delta = to - from;
|
|
delta.y = 0f;
|
|
float dist = math.length(delta);
|
|
if (dist < 1e-5f)
|
|
return to;
|
|
float3 dir = delta / dist;
|
|
const float skin = 0.05f;
|
|
var cw = physics.CollisionWorld;
|
|
if (!cw.SphereCast(from, radius, dir, dist, out var hit, filter))
|
|
return to;
|
|
|
|
float allowed = math.max(0f, hit.Fraction * dist - skin);
|
|
float3 stop = from + dir * allowed;
|
|
stop.y = from.y;
|
|
|
|
// Slide the unused motion along the wall, then sweep the slide so we don't tunnel a second wall.
|
|
float3 slide = EnemyAIMath.SlideVelocity(to - stop, hit.SurfaceNormal);
|
|
float slideDist = math.length(slide);
|
|
if (slideDist < 1e-5f)
|
|
return stop;
|
|
float3 sdir = slide / slideDist;
|
|
float3 result = cw.SphereCast(stop, radius, sdir, slideDist, out var hit2, filter)
|
|
? stop + sdir * math.max(0f, hit2.Fraction * slideDist - skin)
|
|
: stop + slide;
|
|
result.y = from.y;
|
|
return result;
|
|
}
|
|
}
|
|
}
|