kronic
36950ca21d
Aoe/Hitscan archetype dispatch in AbilityFireSystem (both-worlds cooldown; server-only ecb.Instantiate — the client-never-instantiates invariant; ZoneEffect vs DecoyTag chosen by prefab membership). Harpooner REEL as a homing state (ReelState + ReelSystem re-aim the hit Husk's KnockbackState toward the caster's live position each tick; EnemyAISystem stays sole Position writer), stamped by ProjectileDamageSystem on a Reel-flag hit. ZonePulseSystem (enemy-only periodic AoE, caster attribution, no friendly fire, Vortex pull, born-0 lazy-stamp). Decoy aggro in EnemyAISystem + DecoySystem despawn. AbilityDefBlob gains EffectFlags (Reel) + DurationTicks. +3 ZonePulseSystem EditMode tests (497 green). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
332 lines
19 KiB
C#
332 lines
19 KiB
C#
using Unity.Burst;
|
|
using Unity.Collections;
|
|
using Unity.Entities;
|
|
using Unity.Mathematics;
|
|
using Unity.NetCode;
|
|
using Unity.Transforms;
|
|
|
|
namespace ProjectM.Simulation
|
|
{
|
|
/// <summary>
|
|
/// LANTERN 4-socket predicted "fire". On the single fully-predicting pass of each tick, for every player
|
|
/// it loops the 4 ability sockets: a socket whose Spark is set (AbilitySocket.SparkId != 0), whose own
|
|
/// fire event (PlayerInput.Socket0..3) is set this tick, and whose per-socket SocketCooldown has elapsed
|
|
/// fires that Spark. Runs in both worlds: the owning client predict-spawns a Projectile ghost (classified
|
|
/// into the authoritative ghost by ProjectileClassificationSystem via Projectile.SpawnId), and the server
|
|
/// spawns the replicated truth.
|
|
///
|
|
/// The single AbilityRef/AbilityCooldown/EffectiveAbilityStats model was replaced by the socket kit:
|
|
/// AbilitySocket (loadout), SocketCooldown (hot per-socket cooldown), EffectiveSocketStats (per-socket
|
|
/// folded stats from StatRecomputeSystem). To stay under the 7-type SystemAPI.Query cap, the query holds
|
|
/// only PlayerInput/PlayerFacing/LocalTransform/GhostOwner and reads the socket data by entity via
|
|
/// BufferLookup/ComponentLookup (mirroring the BoonEffects lookup).
|
|
///
|
|
/// SpawnId key (owner14 | socket2 | fireCount12 | fork4) reserves socket bits so two sockets firing the
|
|
/// same-prefab projectile on one tick classify to DISTINCT ghosts (the review's NP-1/RS-1/DB-3 fix). The
|
|
/// per-socket fire count comes from the replicated command buffer at ServerTick (not a local counter) so
|
|
/// client and server agree. FORK fans extra predicted projectiles, each with a unique fork index in the
|
|
/// low bits; PIERCE/CHAIN/PULL seed the server-only ProjectileEffectState.
|
|
///
|
|
/// Determinism/idempotency: gated behind IsFirstTimeFullyPredictingTick so a rollback re-sim never
|
|
/// double-spawns. No wall-clock, no System.Random. Predict-spawn is reserved for the Projectile archetype;
|
|
/// Cone/Aoe/Hitscan apply their effect SERVER-ONLY (cooldown predicted on both worlds); the Aoe archetype
|
|
/// instantiates its interpolated ghost server-only. Movement (Blink) falls through to BlinkSystem. Auto-target stays server-only + gamepad-only.
|
|
/// </summary>
|
|
[UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
|
|
[UpdateAfter(typeof(PlayerAimSystem))]
|
|
[BurstCompile]
|
|
public partial struct AbilityFireSystem : ISystem
|
|
{
|
|
// Server-only knockback stamp for the Cone (guarded + boss-immune).
|
|
ComponentLookup<KnockbackState> m_KnockbackLookup;
|
|
ComponentLookup<BossState> m_BossLookup;
|
|
// Owner-replicated mechanic-changer boons, read by the player entity.
|
|
ComponentLookup<BoonEffects> m_BoonEffectsLookup;
|
|
// LANTERN socket kit, read by the player entity so the fire query stays at 4 type args (7-arg cap).
|
|
BufferLookup<AbilitySocket> m_SocketLookup;
|
|
ComponentLookup<SocketCooldown> m_SocketCdLookup;
|
|
BufferLookup<EffectiveSocketStats> m_EffSocketLookup;
|
|
// Prefab-membership + baked transform of an Aoe spawn prefab, read on the PREFAB entity to pick
|
|
// ZoneEffect vs DecoyTag and preserve baked scale. RO; the actual Instantiate is server-only.
|
|
ComponentLookup<ZoneEffect> m_ZoneLookup;
|
|
ComponentLookup<DecoyTag> m_DecoyLookup;
|
|
ComponentLookup<LocalTransform> m_LtLookup;
|
|
|
|
/// <summary>~9 degree gap between adjacent Split-Shot projectiles (tunable).</summary>
|
|
const float k_ForkSpreadRad = 0.157f;
|
|
const float k_AoeCastAhead = 2.5f; // world units ahead of the caster to drop an Aoe/zone/decoy ghost
|
|
const float k_HitscanHalfWidth = 0.6f; // hitscan beam half-width (world units)
|
|
|
|
[BurstCompile]
|
|
public void OnCreate(ref SystemState state)
|
|
{
|
|
state.RequireForUpdate<AbilityDatabase>();
|
|
state.RequireForUpdate<NetworkTime>();
|
|
m_KnockbackLookup = state.GetComponentLookup<KnockbackState>(isReadOnly: false);
|
|
m_BossLookup = state.GetComponentLookup<BossState>(isReadOnly: true);
|
|
m_BoonEffectsLookup = state.GetComponentLookup<BoonEffects>(isReadOnly: true);
|
|
m_SocketLookup = state.GetBufferLookup<AbilitySocket>(isReadOnly: true);
|
|
m_SocketCdLookup = state.GetComponentLookup<SocketCooldown>(isReadOnly: false);
|
|
m_EffSocketLookup = state.GetBufferLookup<EffectiveSocketStats>(isReadOnly: true);
|
|
m_ZoneLookup = state.GetComponentLookup<ZoneEffect>(isReadOnly: true);
|
|
m_DecoyLookup = state.GetComponentLookup<DecoyTag>(isReadOnly: true);
|
|
m_LtLookup = state.GetComponentLookup<LocalTransform>(isReadOnly: true);
|
|
}
|
|
|
|
[BurstCompile]
|
|
public void OnUpdate(ref SystemState state)
|
|
{
|
|
var networkTime = SystemAPI.GetSingleton<NetworkTime>();
|
|
if (!networkTime.IsFirstTimeFullyPredictingTick)
|
|
return;
|
|
var serverTick = networkTime.ServerTick;
|
|
if (!serverTick.IsValid)
|
|
return;
|
|
|
|
var dbEntity = SystemAPI.GetSingletonEntity<AbilityDatabase>();
|
|
var abilityPrefabs = SystemAPI.GetBuffer<AbilityPrefabElement>(dbEntity);
|
|
var abilityDb = SystemAPI.GetSingleton<AbilityDatabase>();
|
|
ref var adb = ref abilityDb.Value.Value;
|
|
|
|
bool isServer = state.WorldUnmanaged.IsServer();
|
|
m_KnockbackLookup.Update(ref state);
|
|
m_BossLookup.Update(ref state);
|
|
m_BoonEffectsLookup.Update(ref state);
|
|
m_SocketLookup.Update(ref state);
|
|
m_SocketCdLookup.Update(ref state);
|
|
m_EffSocketLookup.Update(ref state);
|
|
m_ZoneLookup.Update(ref state);
|
|
m_DecoyLookup.Update(ref state);
|
|
m_LtLookup.Update(ref state);
|
|
|
|
// Server-only LIVING-enemy target set (auto-target assist + Cone cleave), collected once.
|
|
var candidatePositions = new NativeList<float3>(Allocator.Temp);
|
|
var coneTargets = new NativeList<Entity>(Allocator.Temp);
|
|
var coneTargetPos = new NativeList<float3>(Allocator.Temp);
|
|
if (isServer)
|
|
{
|
|
foreach (var (tx, th, te) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>>().WithAll<EnemyTag>().WithEntityAccess())
|
|
{
|
|
if (th.ValueRO.Current <= 0f) continue; // corpses are neither aim magnets nor cleave targets
|
|
candidatePositions.Add(tx.ValueRO.Position);
|
|
coneTargets.Add(te); coneTargetPos.Add(tx.ValueRO.Position);
|
|
}
|
|
}
|
|
var candidates = candidatePositions.AsArray();
|
|
|
|
var ecb = new EntityCommandBuffer(state.WorldUpdateAllocator);
|
|
|
|
foreach (var (input, facing, xform, owner, entity) in
|
|
SystemAPI.Query<RefRO<PlayerInput>, RefRO<PlayerFacing>, RefRO<LocalTransform>, RefRO<GhostOwner>>()
|
|
.WithAll<Simulate>().WithDisabled<Dead>()
|
|
.WithEntityAccess())
|
|
{
|
|
if (!m_SocketLookup.HasBuffer(entity) || !m_SocketCdLookup.HasComponent(entity) || !m_EffSocketLookup.HasBuffer(entity))
|
|
continue;
|
|
var sockets = m_SocketLookup[entity];
|
|
var effSockets = m_EffSocketLookup[entity];
|
|
var cd = m_SocketCdLookup[entity]; // struct copy; written back after mutation
|
|
|
|
BoonEffects bfx = m_BoonEffectsLookup.HasComponent(entity) ? m_BoonEffectsLookup[entity] : default;
|
|
bool pull = (bfx.Flags & BoonFlag.KnockToPull) != 0;
|
|
|
|
// Replicated command buffer at this tick (per-socket fire count for the SpawnId + scheme for aim assist).
|
|
var inputBuffer = SystemAPI.GetBuffer<InputBufferData<PlayerInput>>(entity);
|
|
bool haveApplied = inputBuffer.GetDataAtTick(serverTick, out var applied);
|
|
|
|
bool cdDirty = false;
|
|
int socketCount = math.min(SocketId.Count, sockets.Length);
|
|
for (int sk = 0; sk < socketCount; sk++)
|
|
{
|
|
byte sparkId = sockets[sk].SparkId;
|
|
if (sparkId == 0) continue; // empty socket
|
|
if (!input.ValueRO.GetSocket(sk).IsSet) continue; // this socket not fired this tick
|
|
|
|
// Per-socket cooldown gate (0 = ready).
|
|
uint nextFireRaw = cd.Get(sk);
|
|
if (nextFireRaw != 0)
|
|
{
|
|
var nextTick = new NetworkTick(nextFireRaw);
|
|
if (nextTick.IsValid && nextTick.IsNewerThan(serverTick)) continue;
|
|
}
|
|
|
|
EffectiveSocketStats es = sk < effSockets.Length ? effSockets[sk] : default;
|
|
byte archetype = adb.TryGetAbility(sparkId, out var adef) ? adef.Archetype : (byte)AbilityArchetype.Projectile;
|
|
|
|
// CONE: no projectile ghost. Predict the cooldown on both worlds; apply server-only cleave.
|
|
if (archetype == (byte)AbilityArchetype.Cone)
|
|
{
|
|
if (isServer)
|
|
{
|
|
float2 cFace = facing.ValueRO.Direction;
|
|
cFace = math.lengthsq(cFace) < 1e-6f ? new float2(0f, 1f) : math.normalize(cFace);
|
|
float cRange = math.max(0.1f, es.Range);
|
|
float cCosHalf = math.cos(math.clamp(es.AutoTargetConeRadians, 0.01f, 3.14159f));
|
|
uint cStamp = TickUtil.NonZero(serverTick.TickIndexForValidTick);
|
|
for (int ci = 0; ci < coneTargets.Length; ci++)
|
|
{
|
|
if (!MeleeConeMath.InCone(xform.ValueRO.Position, cFace, cRange, cCosHalf, coneTargetPos[ci]))
|
|
continue;
|
|
ecb.AppendToBuffer(coneTargets[ci], new DamageEvent
|
|
{
|
|
Amount = es.Damage,
|
|
SourceNetworkId = owner.ValueRO.NetworkId,
|
|
SourceTick = cStamp,
|
|
});
|
|
KnockbackUtil.Stamp(ref m_KnockbackLookup, m_BossLookup, coneTargets[ci],
|
|
xform.ValueRO.Position, coneTargetPos[ci], cFace, Tuning.KnockbackSpeed,
|
|
TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, Tuning.KnockbackDurationTicks)), pull);
|
|
}
|
|
}
|
|
cd.Set(sk, TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, es.CooldownTicks)));
|
|
cdDirty = true;
|
|
continue;
|
|
}
|
|
// AOE / ZONE / DECOY (decoy-wisp, vortex, light-zone): predict the cooldown on BOTH worlds;
|
|
// instantiate the interpolated ownerless ghost SERVER-ONLY -- the client must NEVER instantiate it (Build Spec §5).
|
|
if (archetype == (byte)AbilityArchetype.Aoe)
|
|
{
|
|
if (isServer)
|
|
{
|
|
Entity aoePrefab = Entity.Null;
|
|
for (int i = 0; i < abilityPrefabs.Length; i++)
|
|
if (abilityPrefabs[i].Id == sparkId) { aoePrefab = abilityPrefabs[i].Prefab; break; }
|
|
if (aoePrefab != Entity.Null)
|
|
{
|
|
float2 aFace = facing.ValueRO.Direction;
|
|
aFace = math.lengthsq(aFace) < 1e-6f ? new float2(0f, 1f) : math.normalize(aFace);
|
|
float3 spawnPos = xform.ValueRO.Position + new float3(aFace.x, 0f, aFace.y) * k_AoeCastAhead;
|
|
spawnPos.y = xform.ValueRO.Position.y;
|
|
uint expire = adef.DurationTicks > 0
|
|
? TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)adef.DurationTicks) : 0u;
|
|
var bakedLt = m_LtLookup.HasComponent(aoePrefab) ? m_LtLookup[aoePrefab] : LocalTransform.Identity;
|
|
var effect = ecb.Instantiate(aoePrefab);
|
|
ecb.SetComponent(effect, bakedLt.WithPosition(spawnPos));
|
|
if (m_ZoneLookup.HasComponent(aoePrefab))
|
|
ecb.SetComponent(effect, new ZoneEffect
|
|
{
|
|
CasterNetworkId = owner.ValueRO.NetworkId,
|
|
Radius = math.max(0.1f, es.Range),
|
|
DamagePerPulse = es.Damage,
|
|
NextTick = 0u, // lazy-stamped born-correct by ZonePulseSystem (never storm-fires)
|
|
ExpireTick = expire,
|
|
Flags = m_ZoneLookup[aoePrefab].Flags, // Vortex bit baked on the prefab
|
|
});
|
|
else if (m_DecoyLookup.HasComponent(aoePrefab))
|
|
ecb.SetComponent(effect, new DecoyTag { ExpireTick = expire });
|
|
}
|
|
}
|
|
cd.Set(sk, TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, es.CooldownTicks)));
|
|
cdDirty = true;
|
|
continue;
|
|
}
|
|
// HITSCAN: no ghost on either world; predict the cooldown both worlds; server-only swept-beam damage.
|
|
// (No Phase-1 Spark uses Hitscan yet; the branch completes the archetype dispatch per Build Spec §5.)
|
|
if (archetype == (byte)AbilityArchetype.Hitscan)
|
|
{
|
|
if (isServer)
|
|
{
|
|
float2 hFace = facing.ValueRO.Direction;
|
|
hFace = math.lengthsq(hFace) < 1e-6f ? new float2(0f, 1f) : math.normalize(hFace);
|
|
float hRange = math.max(0.1f, es.Range);
|
|
uint hStamp = TickUtil.NonZero(serverTick.TickIndexForValidTick);
|
|
for (int hi = 0; hi < coneTargets.Length; hi++)
|
|
{
|
|
float2 rel = coneTargetPos[hi].xz - xform.ValueRO.Position.xz;
|
|
float t = math.dot(rel, hFace);
|
|
if (t < 0f || t > hRange) continue;
|
|
float2 perp = rel - hFace * t;
|
|
if (math.lengthsq(perp) > k_HitscanHalfWidth * k_HitscanHalfWidth) continue;
|
|
ecb.AppendToBuffer(coneTargets[hi], new DamageEvent
|
|
{
|
|
Amount = es.Damage,
|
|
SourceNetworkId = owner.ValueRO.NetworkId,
|
|
SourceTick = hStamp,
|
|
});
|
|
}
|
|
}
|
|
cd.Set(sk, TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, es.CooldownTicks)));
|
|
cdDirty = true;
|
|
continue;
|
|
}
|
|
// MOVEMENT (Blink) + any other non-Projectile: fall through (BlinkSystem owns the movement socket's cooldown row).
|
|
if (archetype != (byte)AbilityArchetype.Projectile)
|
|
continue;
|
|
|
|
// Resolve the projectile ghost prefab for this Spark id.
|
|
Entity prefab = Entity.Null;
|
|
for (int i = 0; i < abilityPrefabs.Length; i++)
|
|
{
|
|
if (abilityPrefabs[i].Id == sparkId) { prefab = abilityPrefabs[i].Prefab; break; }
|
|
}
|
|
if (prefab == Entity.Null) continue;
|
|
if (!haveApplied) continue;
|
|
|
|
uint socketFireCount = applied.InternalInput.GetSocket(sk).Count;
|
|
|
|
float2 rawAim = facing.ValueRO.Direction;
|
|
rawAim = math.lengthsq(rawAim) < 1e-6f ? new float2(0f, 1f) : math.normalize(rawAim);
|
|
|
|
// Client fires along raw aim; only the server applies the gamepad auto-target assist.
|
|
float2 dir = rawAim;
|
|
if (isServer && es.AutoTargetRange > 0f && applied.InternalInput.Scheme == InputSchemeId.Gamepad)
|
|
{
|
|
dir = AutoTarget.Resolve(xform.ValueRO.Position, rawAim, es.AutoTargetRange, es.AutoTargetConeRadians, candidates);
|
|
}
|
|
|
|
byte pierce = bfx.Pierce;
|
|
byte chain = bfx.Chain;
|
|
byte projFlags = (byte)((pull ? ProjectileEffectFlag.Pull : 0) | adef.EffectFlags);
|
|
int shots = 1 + math.min((int)bfx.Fork, 8);
|
|
|
|
for (int s = 0; s < shots; s++)
|
|
{
|
|
float offset = (s - (shots - 1) * 0.5f) * k_ForkSpreadRad;
|
|
math.sincos(offset, out float sa, out float ca);
|
|
float2 sdir = math.normalize(new float2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca));
|
|
|
|
// SpawnId: owner(14) | socket(2) | fireCount(12) | fork(4) -- see ProjectileSpawnId.
|
|
uint spawnId = ProjectileSpawnId.Pack(owner.ValueRO.NetworkId, sk, socketFireCount, s);
|
|
|
|
var projectile = ecb.Instantiate(prefab);
|
|
float3 planarDir = new float3(sdir.x, 0f, sdir.y);
|
|
float3 spawnPos = xform.ValueRO.Position + planarDir * 0.6f;
|
|
spawnPos.y = xform.ValueRO.Position.y;
|
|
quaternion rot = quaternion.LookRotationSafe(planarDir, math.up());
|
|
|
|
ecb.SetComponent(projectile, LocalTransform.FromPositionRotation(spawnPos, rot));
|
|
ecb.SetComponent(projectile, new GhostOwner { NetworkId = owner.ValueRO.NetworkId });
|
|
ecb.SetComponent(projectile, new Projectile
|
|
{
|
|
Direction = sdir,
|
|
SpawnId = spawnId,
|
|
Speed = es.ProjectileSpeed,
|
|
Damage = es.Damage,
|
|
Range = es.Range,
|
|
DistanceTravelled = 0f,
|
|
});
|
|
ecb.SetComponent(projectile, new ProjectileEffectState
|
|
{
|
|
PierceRemaining = pierce,
|
|
ChainRemaining = chain,
|
|
Flags = projFlags,
|
|
});
|
|
}
|
|
|
|
cd.Set(sk, TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, es.CooldownTicks)));
|
|
cdDirty = true;
|
|
}
|
|
|
|
if (cdDirty) m_SocketCdLookup[entity] = cd;
|
|
}
|
|
|
|
ecb.Playback(state.EntityManager);
|
|
ecb.Dispose();
|
|
candidatePositions.Dispose();
|
|
coneTargets.Dispose();
|
|
coneTargetPos.Dispose();
|
|
}
|
|
}
|
|
}
|