271 lines
14 KiB
C#
271 lines
14 KiB
C#
using ProjectM.Simulation;
|
|
using Unity.Burst;
|
|
using Unity.Collections;
|
|
using Unity.Entities;
|
|
using Unity.Mathematics;
|
|
using Unity.NetCode;
|
|
using Unity.Transforms;
|
|
|
|
namespace ProjectM.Server
|
|
{
|
|
/// <summary>
|
|
/// Server-authoritative projectile resolution: applies hits to damageable entities and expires
|
|
/// projectiles past their range. Runs in the server world only
|
|
/// (<see cref="WorldSystemFilterFlags.ServerSimulation"/>) inside the
|
|
/// <see cref="PredictedSimulationSystemGroup"/>, ordered <see cref="ProjectileMoveSystem"/> so the
|
|
/// projectile's <see cref="LocalTransform"/> is the post-move position for this tick.
|
|
///
|
|
/// Hit detection is a <b>swept</b> planar (XZ) test: rather than checking the projectile's point
|
|
/// position (which tunnels straight through a target when the per-tick step exceeds the target's
|
|
/// radius — e.g. a fast projectile, or any projectile while the server is tick-batching under load),
|
|
/// it reconstructs the segment the projectile traversed this tick
|
|
/// (<c>[curPos - dir*speed*dt, curPos]</c>) and tests each target's hit radius against the closest
|
|
/// point on that segment. The target hit earliest along the path (smallest segment parameter) wins.
|
|
/// A target whose <see cref="GhostOwner"/> matches the projectile's owner is skipped (no self-hits);
|
|
/// dummies carry no <see cref="GhostOwner"/> and are therefore always valid targets.
|
|
///
|
|
/// Phase 1.7 mechanic-changer boons ride the server-only <see cref="ProjectileEffectState"/> (seeded at
|
|
/// spawn by <c>AbilityFireSystem</c> from the owner's <see cref="BoonEffects"/>): PIERCE lets the projectile
|
|
/// survive a hit (decrement, don't destroy), CHAIN retargets its (replicated) <see cref="Projectile.Direction"/>
|
|
/// toward the next-nearest living enemy, and PULL flips the knockback heading toward the shooter. A per-projectile
|
|
/// hit-set is excluded DURING target selection so a surviving projectile never re-hits a target across ticks; the
|
|
/// set full (or no pierce/chain left) destroys as before. Projectiles WITHOUT the component behave exactly as
|
|
/// before (destroy on hit) — graceful degradation. Exactly ONE destroy per projectile per tick is preserved.
|
|
///
|
|
/// On a hit the system appends a <see cref="DamageEvent"/> to the target (consumed by
|
|
/// <c>HealthApplyDamageSystem</c>). Deferring damage to a buffer lets a single tick stack hits from multiple
|
|
/// projectiles. All structural changes go through an <see cref="EntityCommandBuffer"/> that plays back
|
|
/// immediately to the <see cref="EntityManager"/> (Temp allocator).
|
|
/// </summary>
|
|
[BurstCompile]
|
|
[WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
|
|
[UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
|
|
[UpdateAfter(typeof(ProjectileMoveSystem))]
|
|
public partial struct ProjectileDamageSystem : ISystem
|
|
{
|
|
/// <summary>Lookup used to read a target's owner so a projectile never hits its own caster.</summary>
|
|
ComponentLookup<GhostOwner> m_GhostOwnerLookup;
|
|
|
|
/// <summary>RW lookup to stamp server-only knockback on a hit Husk (Husks bake KnockbackState; players/dummies don't).</summary>
|
|
ComponentLookup<KnockbackState> m_KnockbackLookup;
|
|
|
|
/// <summary>Read-only lookup so a BOSS (BossState) is skipped by the knockback stamp — the boss is
|
|
/// knockback-immune (A4) so a solo player can't perma-stunlock it out of its slam wind-ups.</summary>
|
|
ComponentLookup<BossState> m_BossLookup;
|
|
|
|
/// <summary>RW lookup for the per-projectile Phase-1.7 pierce/chain/pull state + re-hit set.</summary>
|
|
ComponentLookup<ProjectileEffectState> m_FxLookup;
|
|
|
|
/// <summary>Extra forgiveness added to a target's hit radius to approximate the projectile's own size.</summary>
|
|
const float k_ProjectileRadius = 0.2f;
|
|
|
|
/// <summary>Max planar distance a Ricochet chain will reach for its next target (tunable).</summary>
|
|
const float k_ChainRange = 8f;
|
|
|
|
[BurstCompile]
|
|
public void OnCreate(ref SystemState state)
|
|
{
|
|
m_GhostOwnerLookup = state.GetComponentLookup<GhostOwner>(isReadOnly: true);
|
|
m_KnockbackLookup = state.GetComponentLookup<KnockbackState>(isReadOnly: false);
|
|
m_BossLookup = state.GetComponentLookup<BossState>(isReadOnly: true);
|
|
m_FxLookup = state.GetComponentLookup<ProjectileEffectState>(isReadOnly: false);
|
|
|
|
// No projectiles → nothing to expire or hit-test; skip the tick (and its allocations) entirely.
|
|
state.RequireForUpdate<Projectile>();
|
|
}
|
|
|
|
[BurstCompile]
|
|
public void OnUpdate(ref SystemState state)
|
|
{
|
|
m_GhostOwnerLookup.Update(ref state);
|
|
m_KnockbackLookup.Update(ref state);
|
|
m_BossLookup.Update(ref state);
|
|
m_FxLookup.Update(ref state);
|
|
|
|
bool haveTick = SystemAPI.TryGetSingleton<NetworkTime>(out var nt);
|
|
|
|
float dt = SystemAPI.Time.DeltaTime;
|
|
var ecb = new EntityCommandBuffer(Allocator.Temp);
|
|
|
|
// Snapshot all damageable targets once for this tick. Stable iteration order (query order).
|
|
var targetEntities = new NativeList<Entity>(Allocator.Temp);
|
|
var targetPositions = new NativeList<float3>(Allocator.Temp);
|
|
var targetRadii = new NativeList<float>(Allocator.Temp);
|
|
|
|
foreach (var (xform, hitRadius, targetEntity) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<HitRadius>>()
|
|
.WithAll<Health>()
|
|
.WithNone<Dying>() // B3: corpses are not shields - a shot passes through to living targets
|
|
.WithEntityAccess())
|
|
{
|
|
targetEntities.Add(targetEntity);
|
|
targetPositions.Add(xform.ValueRO.Position);
|
|
targetRadii.Add(hitRadius.ValueRO.Value);
|
|
}
|
|
|
|
foreach (var (xform, proj, owner, projectileEntity) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRW<Projectile>, RefRO<GhostOwner>>()
|
|
.WithEntityAccess())
|
|
{
|
|
int projOwnerId = owner.ValueRO.NetworkId;
|
|
|
|
bool hasFx = m_FxLookup.HasComponent(projectileEntity);
|
|
ProjectileEffectState fx = hasFx ? m_FxLookup[projectileEntity] : default;
|
|
|
|
// This tick's planar travel segment: [segStart -> segEnd]. Sweeping the segment (rather
|
|
// than testing only segEnd) is what prevents fast projectiles from tunnelling targets.
|
|
float3 cur = xform.ValueRO.Position;
|
|
float2 segEnd = new float2(cur.x, cur.z);
|
|
float2 segStart = segEnd - proj.ValueRO.Direction * (proj.ValueRO.Speed * dt);
|
|
float2 seg = segEnd - segStart;
|
|
float segLenSq = math.lengthsq(seg);
|
|
|
|
int bestIdx = -1;
|
|
float bestT = float.MaxValue;
|
|
for (int i = 0; i < targetEntities.Length; i++)
|
|
{
|
|
var target = targetEntities[i];
|
|
|
|
// Skip the caster: a target whose GhostOwner matches the projectile owner is the
|
|
// shooter (or another ghost they own). Dummies have no GhostOwner, so never skipped.
|
|
if (m_GhostOwnerLookup.HasComponent(target) &&
|
|
m_GhostOwnerLookup[target].NetworkId == projOwnerId)
|
|
continue;
|
|
|
|
// Phase 1.7: a surviving (pierced/chained) projectile never re-hits a target already struck —
|
|
// excluded DURING selection, not post-filtered.
|
|
if (hasFx && HitSetContains(in fx, target))
|
|
continue;
|
|
|
|
float2 tp = new float2(targetPositions[i].x, targetPositions[i].z);
|
|
|
|
// Closest point on the travel segment to the target centre.
|
|
float t = segLenSq > 1e-8f
|
|
? math.saturate(math.dot(tp - segStart, seg) / segLenSq)
|
|
: 0f;
|
|
float2 closest = segStart + t * seg;
|
|
|
|
float hitDist = targetRadii[i] + k_ProjectileRadius;
|
|
if (math.distancesq(tp, closest) <= hitDist * hitDist && t < bestT)
|
|
{
|
|
bestT = t;
|
|
bestIdx = i;
|
|
}
|
|
}
|
|
|
|
if (bestIdx >= 0)
|
|
{
|
|
var hitTarget = targetEntities[bestIdx];
|
|
|
|
// Earliest target along the travel path: deal damage.
|
|
ecb.AppendToBuffer(hitTarget, new DamageEvent
|
|
{
|
|
Amount = proj.ValueRO.Damage,
|
|
SourceNetworkId = projOwnerId,
|
|
SourceTick = haveTick ? TickUtil.NonZero(nt.ServerTick.TickIndexForValidTick) : 0u,
|
|
});
|
|
|
|
// Knockback (Phase 1.7: PULL flips the heading toward the shooter when the owner's boon is set).
|
|
if (haveTick && Tuning.KnockbackSpeed > 0f && m_KnockbackLookup.HasComponent(hitTarget) && !m_BossLookup.HasComponent(hitTarget))
|
|
{
|
|
bool pull = hasFx && (fx.Flags & ProjectileEffectFlag.Pull) != 0;
|
|
float2 kdir = pull ? -proj.ValueRO.Direction : proj.ValueRO.Direction;
|
|
m_KnockbackLookup[hitTarget] = new KnockbackState
|
|
{
|
|
Dir = kdir,
|
|
Speed = Tuning.KnockbackSpeed,
|
|
UntilTick = TickUtil.NonZero(nt.ServerTick.TickIndexForValidTick + (uint)math.max(1, Tuning.KnockbackDurationTicks)),
|
|
};
|
|
}
|
|
|
|
// Phase 1.7: pierce/chain let the projectile SURVIVE; else it is consumed. Record the target so it
|
|
// can't be re-hit. A full hit-set is a natural cap → destroy.
|
|
bool survive = false;
|
|
if (hasFx)
|
|
{
|
|
if (fx.Hit.Length < fx.Hit.Capacity)
|
|
{
|
|
fx.Hit.Add(hitTarget);
|
|
if (fx.PierceRemaining > 0)
|
|
{
|
|
fx.PierceRemaining = (byte)(fx.PierceRemaining - 1);
|
|
survive = true;
|
|
}
|
|
else if (fx.ChainRemaining > 0)
|
|
{
|
|
int nextIdx = FindChainTarget(targetEntities, targetPositions, cur, projOwnerId, in fx);
|
|
if (nextIdx >= 0)
|
|
{
|
|
float2 to = new float2(targetPositions[nextIdx].x - cur.x, targetPositions[nextIdx].z - cur.z);
|
|
if (math.lengthsq(to) > 1e-6f)
|
|
{
|
|
proj.ValueRW.Direction = math.normalize(to);
|
|
fx.ChainRemaining = (byte)(fx.ChainRemaining - 1);
|
|
survive = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_FxLookup[projectileEntity] = fx;
|
|
}
|
|
|
|
if (survive)
|
|
{
|
|
// A surviving projectile still expires once it has travelled its full range.
|
|
if (proj.ValueRO.DistanceTravelled >= proj.ValueRO.Range)
|
|
ecb.DestroyEntity(projectileEntity);
|
|
continue;
|
|
}
|
|
|
|
ecb.DestroyEntity(projectileEntity);
|
|
continue;
|
|
}
|
|
|
|
// Nothing hit this tick: expire the projectile once it has travelled its full range.
|
|
if (proj.ValueRO.DistanceTravelled >= proj.ValueRO.Range)
|
|
ecb.DestroyEntity(projectileEntity);
|
|
}
|
|
|
|
ecb.Playback(state.EntityManager);
|
|
|
|
ecb.Dispose();
|
|
targetEntities.Dispose();
|
|
targetPositions.Dispose();
|
|
targetRadii.Dispose();
|
|
}
|
|
|
|
/// <summary>True when <paramref name="target"/> is already in the projectile's re-hit history.</summary>
|
|
static bool HitSetContains(in ProjectileEffectState fx, Entity target)
|
|
{
|
|
for (int i = 0; i < fx.Hit.Length; i++)
|
|
if (fx.Hit[i] == target) return true;
|
|
return false;
|
|
}
|
|
|
|
/// <summary>Nearest living target to <paramref name="from"/> within <see cref="k_ChainRange"/> that is neither
|
|
/// the caster's own ghost nor already in the projectile's hit-set. Returns the snapshot index or -1.</summary>
|
|
int FindChainTarget(in NativeList<Entity> targetEntities, in NativeList<float3> targetPositions,
|
|
float3 from, int projOwnerId, in ProjectileEffectState fx)
|
|
{
|
|
int best = -1;
|
|
float bestDistSq = k_ChainRange * k_ChainRange;
|
|
for (int i = 0; i < targetEntities.Length; i++)
|
|
{
|
|
var target = targetEntities[i];
|
|
if (m_GhostOwnerLookup.HasComponent(target) && m_GhostOwnerLookup[target].NetworkId == projOwnerId)
|
|
continue;
|
|
if (HitSetContains(in fx, target))
|
|
continue;
|
|
float2 d = new float2(targetPositions[i].x - from.x, targetPositions[i].z - from.z);
|
|
float dsq = math.lengthsq(d);
|
|
if (dsq <= bestDistSq)
|
|
{
|
|
bestDistSq = dsq;
|
|
best = i;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
}
|
|
}
|