kronic
ea108e48e4
B1 SEPARATION: pairwise soft-collision pass INSIDE EnemyAISystem (sole enemy-Position writer preserved; O(n^2) fine at MaxAlive<=14). Knocked/ lunging enemies keep committed motion but still push neighbours; the boss is never pushed; enemies yield a small personal radius around players (below melee range per review B1-1); displacement goes through the swept move so nothing shoves through walls. SeparationMaxSpeed = live knob. B2 POISE: the windup-cancel lived in the knockback CONTINUE branches (grunt/ charger/spitter). Threshold on the EXISTING KnockbackState.Speed channel: light melee (6) nudges without interrupting; the finisher (10.8) and cone (8) stagger as before. StaggerKnockbackSpeed = live knob (default 7). B4 BOSS LUNGE: a telegraphed gap-closer on its own cooldown when the target sits outside slam reach (repositioning - the slam stays the damage beat). BossState.PendingAttack (server-only byte) disambiguates the shared windup elapse (review-confirmed: naive reuse would SLAM on a lunge elapse); LungeState.UntilTick spans windup+travel so the existing IsLunging ghost bit replicates the tell, and the client draws a travel wedge instead of the slam ring while it is set. B5 PARTY HP SCALE: boss Health x(1 + 0.75/extra LIVING expedition player) at spawn (not RunParticipant - dead-respawned members park at base). Max is a GhostField so the bar stays truthful. B6 RUN-FAILED BANNER: silent wipes used to land players home with zero explanation. Client detects the (in-run)->Staging edge with a launch-cached Charge (NEVER Returning - a 1-tick transient that precedes the bank by a tick) and shows EXPEDITION FAILED for 6 s. B7 FIRE ANIM: the class ability finally moves the body - a stateless window from replicated AbilityCooldown.NextFireTick minus derived CooldownTicks (works for predicted local + interpolated remotes, no cached edges). 456/456 EditMode; live Play smoke: launch -> 5 kills credit the room clear through the corpse window -> boon window opens -> corpses expire clean, no exceptions. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
262 lines
15 KiB
C#
262 lines
15 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 EXPEDITION BOSS brain — the SOLE mover/attacker of <c>.WithAll<EnemyTag, BossState>()</c>
|
||
/// (EnemyAISystem's Charger MOVE pass excludes it via <c>.WithNone<BossState>()</c>, so exactly one system
|
||
/// writes the boss's Position/Rotation/AttackWindup — the sole-writer invariant). Runs SERVER-ONLY in the plain
|
||
/// <see cref="SimulationSystemGroup"/> <c>[UpdateAfter(EnemyAISystem)]</c> (a linear chain, no sort cycle), once per
|
||
/// tick (interpolated ghost, no rollback → no Simulate filter, no IsFirstTimeFullyPredictingTick).
|
||
///
|
||
/// v2 boss = a real fight (operator-locked): chase the nearest living expedition player, then a telegraphed radial
|
||
/// SLAM — the client danger cue rides the replicated <see cref="AttackWindup"/> [GhostField] (CombatFeedbackSystem
|
||
/// draws a boss-scale ring). At/below <see cref="Tuning.BossPhase2HealthFraction"/> HP it enters phase two: faster,
|
||
/// slams more often, and periodically summons swarmer adds. B4 (Phase 1): the boss ALSO lunges - a telegraphed
|
||
/// gap-closer on its own cooldown when the target sits outside slam reach; LungeState.UntilTick spans the
|
||
/// windup+travel so EnemyAISystem's IsLunging derive replicates the tell (the client suppresses the slam ring
|
||
/// off that bit), and BossState.PendingAttack (server-only byte) tells the shared windup-elapse branch WHICH
|
||
/// attack fires. Knockback-immune (the stamp
|
||
/// sites skip BossState; this system also clears any residual so nothing else can shove it). Summoned adds go
|
||
/// through <see cref="ZoneEnemySpawnUtil"/> so they carry the SAME ZoneEnemyTag/RoomTag/RegionTag stack the
|
||
/// room-clear gate + teardown depend on (dropping one would leak adds or clear the room early). All ticks route
|
||
/// through <c>TickUtil.NonZero</c> and compare with <see cref="NetworkTick"/> only (never raw uint).
|
||
/// </summary>
|
||
[BurstCompile]
|
||
[WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
|
||
[UpdateInGroup(typeof(SimulationSystemGroup))]
|
||
[UpdateAfter(typeof(EnemyAISystem))]
|
||
public partial struct BossAISystem : ISystem
|
||
{
|
||
EntityQuery m_Bosses;
|
||
EntityQuery m_ZoneEnemies;
|
||
|
||
[BurstCompile]
|
||
public void OnCreate(ref SystemState state)
|
||
{
|
||
state.RequireForUpdate<NetworkTime>();
|
||
m_Bosses = state.GetEntityQuery(ComponentType.ReadOnly<EnemyTag>(), ComponentType.ReadOnly<BossState>(), ComponentType.Exclude<Dying>());
|
||
state.RequireForUpdate(m_Bosses);
|
||
m_ZoneEnemies = state.GetEntityQuery(ComponentType.ReadOnly<ZoneEnemyTag>(), ComponentType.Exclude<Dying>()); // summon cap counts LIVING only (B3)
|
||
}
|
||
|
||
[BurstCompile]
|
||
public void OnUpdate(ref SystemState state)
|
||
{
|
||
var serverTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
|
||
if (!serverTick.IsValid)
|
||
return;
|
||
uint now = serverTick.TickIndexForValidTick;
|
||
float dt = SystemAPI.Time.DeltaTime;
|
||
|
||
// Living EXPEDITION players — the boss's only valid targets. Snapshot once (stable query order).
|
||
var playerEntities = new NativeList<Entity>(Allocator.Temp);
|
||
var playerPositions = new NativeList<float3>(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 || region.ValueRO.Region != RegionId.Expedition)
|
||
continue;
|
||
playerEntities.Add(entity);
|
||
playerPositions.Add(xform.ValueRO.Position);
|
||
}
|
||
|
||
// Collide-and-slide setup (mirrors EnemyAISystem).
|
||
bool havePhysics = SystemAPI.TryGetSingleton<PhysicsWorldSingleton>(out var physics);
|
||
uint envMask = SystemAPI.TryGetSingleton<WorldCollisionConfig>(out var worldCol) ? worldCol.EnvironmentMask : 0u;
|
||
uint sweepMask = envMask | worldCol.StructureMask;
|
||
var envFilter = new CollisionFilter { BelongsTo = ~0u, CollidesWith = sweepMask, GroupIndex = 0 };
|
||
bool sweep = havePhysics && sweepMask != 0u;
|
||
const float SweepRadius = 0.8f; // the boss is a big body
|
||
|
||
int liveZone = m_ZoneEnemies.CalculateEntityCount();
|
||
|
||
// Summon resources (phase two): the swarmer prefab + baked transform + the current room byte.
|
||
bool haveDirector = SystemAPI.TryGetSingletonEntity<ZoneEnemyDirector>(out var directorEntity);
|
||
Entity swarmerPrefab = Entity.Null;
|
||
LocalTransform swarmerBaked = default;
|
||
if (haveDirector)
|
||
{
|
||
var prefabs = SystemAPI.GetBuffer<ZoneEnemyPrefab>(directorEntity);
|
||
if (prefabs.Length > ZoneEnemyMath.KindSwarmer)
|
||
{
|
||
swarmerPrefab = prefabs[ZoneEnemyMath.KindSwarmer].Prefab;
|
||
if (swarmerPrefab != Entity.Null)
|
||
swarmerBaked = state.EntityManager.GetComponentData<LocalTransform>(swarmerPrefab);
|
||
}
|
||
}
|
||
byte roomByte = SystemAPI.TryGetSingleton<RunInfo>(out var runInfo) ? (byte)(runInfo.CurrentRoom & 0xFF) : (byte)0;
|
||
|
||
var ecb = new EntityCommandBuffer(Allocator.Temp);
|
||
|
||
foreach (var (xform, stats, health, boss, windup, knockback, lunge) in
|
||
SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRO<Health>, RefRW<BossState>,
|
||
RefRW<AttackWindup>, RefRW<KnockbackState>, RefRW<LungeState>>()
|
||
.WithAll<EnemyTag, BossState>().WithNone<Dying>())
|
||
{
|
||
float3 pos = xform.ValueRO.Position;
|
||
|
||
// Knockback-immune: never recoil (A4). Zero any residual so a competing stamp can't shove the boss.
|
||
if (knockback.ValueRO.UntilTick != 0u) knockback.ValueRW.UntilTick = 0u;
|
||
|
||
// Phase from the boss's own Current vs (server-side, real ×BossHealthMultiplier) Max.
|
||
float maxHp = math.max(1f, health.ValueRO.Max);
|
||
byte phase = health.ValueRO.Current <= maxHp * Tuning.BossPhase2HealthFraction ? (byte)2 : (byte)1;
|
||
boss.ValueRW.Phase = phase;
|
||
|
||
// Target: nearest living expedition player.
|
||
int tgt = -1; float bestSq = float.MaxValue;
|
||
for (int i = 0; i < playerPositions.Length; i++)
|
||
{
|
||
float d = math.distancesq(pos, playerPositions[i]);
|
||
if (d < bestSq) { bestSq = d; tgt = i; }
|
||
}
|
||
if (tgt < 0)
|
||
continue; // no valid target -> idle (InRoom-abort handles a fully-empty expedition)
|
||
float3 targetPos = playerPositions[tgt];
|
||
|
||
// Face the target (planar) at all times, incl. while telegraphing.
|
||
float3 toTarget = targetPos - pos; toTarget.y = 0f;
|
||
if (math.lengthsq(toTarget) > 1e-6f)
|
||
xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(toTarget), math.up());
|
||
|
||
// --- SLAM in progress: root (the telegraph) until it lands, then AoE all players in the ring. ---
|
||
uint windRaw = windup.ValueRO.WindUpUntilTick;
|
||
if (windRaw != 0u)
|
||
{
|
||
var wt = new NetworkTick(windRaw);
|
||
if (!(wt.IsValid && wt.IsNewerThan(serverTick)))
|
||
{
|
||
// B4: the windup elapse fires whichever attack was PENDING - the shared AttackWindup field
|
||
// alone cannot tell them apart (review-confirmed: the naive reuse slams on a lunge elapse).
|
||
if (boss.ValueRO.PendingAttack == 1)
|
||
{
|
||
// Lunge commit: lock direction at travel start (the Charger contract - dodge DURING
|
||
// travel with dash i-frames). No unique damage: arriving re-opens the slam threat.
|
||
lunge.ValueRW.Dir = math.normalizesafe(toTarget.xz, new float2(0f, 1f));
|
||
lunge.ValueRW.Speed = Tuning.BossLungeSpeed;
|
||
lunge.ValueRW.UntilTick = TickUtil.NonZero(now + Tuning.BossLungeDurationTicks);
|
||
windup.ValueRW.WindUpUntilTick = 0u;
|
||
continue;
|
||
}
|
||
float slamSq = Tuning.BossSlamRadius * Tuning.BossSlamRadius;
|
||
for (int i = 0; i < playerEntities.Length; i++)
|
||
{
|
||
if (math.distancesq(pos, playerPositions[i]) > slamSq)
|
||
continue;
|
||
ecb.AppendToBuffer(playerEntities[i], new DamageEvent
|
||
{
|
||
Amount = Tuning.BossSlamDamage,
|
||
SourceNetworkId = -1, // environment / boss, not a player
|
||
SourceTick = TickUtil.NonZero(now),
|
||
});
|
||
}
|
||
windup.ValueRW.WindUpUntilTick = 0u;
|
||
uint baseCd = Tuning.BossSlamCooldownTicks;
|
||
uint cd = phase == 2
|
||
? (uint)math.max(1f, baseCd * Tuning.BossPhase2SlamCooldownMult)
|
||
: baseCd;
|
||
boss.ValueRW.SlamReadyTick = TickUtil.NonZero(now + cd);
|
||
}
|
||
continue; // rooted while winding up (the tell); rotation already written above
|
||
}
|
||
|
||
// --- B4 LUNGE travel in progress: committed movement along the locked direction. Wall-stop or
|
||
// timer ends it (the Charger contract); the replicated IsLunging bit rides LungeState.UntilTick. ---
|
||
if (lunge.ValueRO.UntilTick != 0u)
|
||
{
|
||
var blt = new NetworkTick(lunge.ValueRO.UntilTick);
|
||
if (blt.IsValid && blt.IsNewerThan(serverTick))
|
||
{
|
||
float3 intended = pos + new float3(lunge.ValueRO.Dir.x, 0f, lunge.ValueRO.Dir.y) * (lunge.ValueRO.Speed * dt);
|
||
intended.y = pos.y;
|
||
float3 moved = sweep ? EnemyMoveUtil.SweptMove(in physics, pos, intended, SweepRadius, envFilter) : intended;
|
||
xform.ValueRW.Position = moved;
|
||
if (math.lengthsq(lunge.ValueRO.Dir) > 1e-6f)
|
||
xform.ValueRW.Rotation = quaternion.LookRotationSafe(new float3(lunge.ValueRO.Dir.x, 0f, lunge.ValueRO.Dir.y), math.up());
|
||
float intendedDist = math.distance(pos.xz, intended.xz);
|
||
float actualDist = math.distance(pos.xz, moved.xz);
|
||
if (intendedDist > 1e-4f && actualDist < intendedDist * 0.5f)
|
||
{
|
||
lunge.ValueRW.UntilTick = 0u; // wall-stop -> end the travel early
|
||
boss.ValueRW.PendingAttack = 0;
|
||
boss.ValueRW.LungeReadyTick = TickUtil.NonZero(now + Tuning.BossLungeCooldownTicks);
|
||
}
|
||
continue; // committed this tick
|
||
}
|
||
lunge.ValueRW.UntilTick = 0u; // travel done
|
||
boss.ValueRW.PendingAttack = 0;
|
||
boss.ValueRW.LungeReadyTick = TickUtil.NonZero(now + Tuning.BossLungeCooldownTicks);
|
||
}
|
||
|
||
// --- Chase (no active slam). ---
|
||
float speed = stats.ValueRO.MoveSpeed * (phase == 2 ? Tuning.BossPhase2SpeedMult : 1f);
|
||
float stopDist = stats.ValueRO.AttackRange * 0.9f;
|
||
float3 vel = EnemyAIMath.SeekVelocity(pos, targetPos, speed, stopDist);
|
||
float3 newPos = pos + vel * dt; newPos.y = pos.y;
|
||
if (sweep) newPos = EnemyMoveUtil.SweptMove(in physics, pos, newPos, SweepRadius, envFilter);
|
||
xform.ValueRW.Position = newPos;
|
||
|
||
// Slam gate: ready + a player inside (ring + a small lead) -> commit a telegraphed slam.
|
||
bool slamReady = boss.ValueRO.SlamReadyTick == 0u
|
||
|| !new NetworkTick(boss.ValueRO.SlamReadyTick).IsNewerThan(serverTick);
|
||
float lead = Tuning.BossSlamRadius + 1.5f;
|
||
float tgtDistSq = math.distancesq(newPos, targetPos);
|
||
if (slamReady && tgtDistSq <= lead * lead)
|
||
{
|
||
windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + Tuning.BossSlamWindupTicks);
|
||
boss.ValueRW.PendingAttack = 0;
|
||
}
|
||
else
|
||
{
|
||
// B4 lunge gate: target out of slam reach but within lunge range -> telegraphed gap-closer.
|
||
// LungeState.UntilTick spans windup+travel so the IsLunging ghost bit (derived by EnemyAISystem
|
||
// from LungeState) is ON for the whole move - the client suppresses the slam ring off that bit.
|
||
bool lungeReady = boss.ValueRO.LungeReadyTick == 0u
|
||
|| !new NetworkTick(boss.ValueRO.LungeReadyTick).IsNewerThan(serverTick);
|
||
if (lungeReady
|
||
&& tgtDistSq >= Tuning.BossLungeMinRange * Tuning.BossLungeMinRange
|
||
&& tgtDistSq <= Tuning.BossLungeMaxRange * Tuning.BossLungeMaxRange)
|
||
{
|
||
windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + Tuning.BossLungeWindupTicks);
|
||
boss.ValueRW.PendingAttack = 1;
|
||
lunge.ValueRW.UntilTick = TickUtil.NonZero(now + Tuning.BossLungeWindupTicks + Tuning.BossLungeDurationTicks);
|
||
}
|
||
}
|
||
|
||
// Summon (phase two only): ready + under the live cap + a swarmer prefab wired.
|
||
if (phase == 2 && swarmerPrefab != Entity.Null && liveZone < Tuning.BossSummonLiveCap)
|
||
{
|
||
bool summonReady = boss.ValueRO.SummonReadyTick == 0u
|
||
|| !new NetworkTick(boss.ValueRO.SummonReadyTick).IsNewerThan(serverTick);
|
||
if (summonReady)
|
||
{
|
||
int toSpawn = math.min(Tuning.BossSummonCount, Tuning.BossSummonLiveCap - liveZone);
|
||
for (int k = 0; k < toSpawn; k++)
|
||
{
|
||
float3 spawnPos = EnemyAIMath.ClusterOffset(newPos, k, math.max(1, toSpawn), 2.5f);
|
||
spawnPos.y = newPos.y;
|
||
ZoneEnemySpawnUtil.Spawn(ecb, swarmerPrefab, in swarmerBaked, spawnPos, RegionId.Expedition, roomByte);
|
||
liveZone++;
|
||
}
|
||
boss.ValueRW.SummonReadyTick = TickUtil.NonZero(now + Tuning.BossSummonCooldownTicks);
|
||
}
|
||
}
|
||
}
|
||
|
||
ecb.Playback(state.EntityManager);
|
||
ecb.Dispose();
|
||
playerEntities.Dispose();
|
||
playerPositions.Dispose();
|
||
}
|
||
}
|
||
}
|