kronic
21a4c71413
- KnockbackUtil.Stamp: shared knockback-stamp used by AbilityFireSystem + MeleeComboSystem (guard + planar normalize + write; speed passed in). - BakerStructureExt: AddPlacedStructure/AddDamageable extensions on Baker<T>; rewired Turret/Structure/Harvester/Conveyor/Fabricator bakers (baked data + serialized fields unchanged). - EnemyPrefabBakeExt.AddEnemyPrefabPool: shared prefab-buffer bake for ZoneEnemyDirector/WaveDirector authoring (fields stay flat — no serialization change). - Editor AnimRigUtil (HasParam + root-yaw overlay clip) shared by PlayerRigTools/EnemyRigTools; EnemyRigTools.MakeMat now GUID-preserving (CopySerialized over existing) — the composite AnimatorController copy left as-is with a caveat comment. 466/466 EditMode tests pass, 0 warnings. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
331 lines
19 KiB
C#
331 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>One server-side cleave queued from a player's swing-start this tick, resolved after the player loop so
|
|
/// the living-enemy snapshot is gathered ONCE and ONLY when a swing actually fired (never on the client, never on an
|
|
/// idle tick). Blittable (Burst-friendly).</summary>
|
|
struct PendingCleave
|
|
{
|
|
public float3 From;
|
|
public float2 Face;
|
|
public float Damage;
|
|
public float Range;
|
|
public float KnockSpeed;
|
|
public int OwnerId;
|
|
public uint Stamp;
|
|
public uint KnockUntil;
|
|
}
|
|
|
|
/// <summary>
|
|
/// MC-4 — the predicted melee combo (Hades-style 2-3 hit chain; the player's PRIMARY verb). On a fresh
|
|
/// <see cref="PlayerInput.Attack"/> press (not locked, not mid-dash) it ADVANCES <see cref="MeleeCombo.Step"/>
|
|
/// (chain if re-pressed inside [LockUntilTick, LockUntilTick + grace), else reset to 1) and opens a movement-commit
|
|
/// lock; the finisher (Step == ComboLength) hits bigger. The Step/SwingStartTick/LockUntilTick anchor is
|
|
/// owner-replicated (<see cref="MeleeCombo"/> [GhostField]s) so a rollback restores the authoritative combo
|
|
/// position; every write is an ABSOLUTE function of (restored Step, tick) — re-running a tick re-derives identical
|
|
/// state (the DashSystem idempotency idiom; never an in-place prev+1 of a non-restored field — MC-4 review PRED-1).
|
|
/// <para>
|
|
/// Runs in <see cref="PredictedSimulationSystemGroup"/> AFTER <see cref="PlayerControlSystem"/> (it scales the
|
|
/// MoveVelocity that system wrote) and BEFORE <see cref="DashSystem"/> (a dash OVERRIDES the swing's movement =
|
|
/// dash-cancel) — and so before HealthApplyDamageSystem ([UpdateAfter(DashSystem)]) which drains the cleave's
|
|
/// DamageEvent the same tick. Movement-commit re-applies every predicted pass, lower-bounded on SwingStartTick (a
|
|
/// re-simulated pre-swing tick must NOT inherit the scale — the DashSystem inDashWindow fix). DAMAGE is SERVER-ONLY
|
|
/// (enemies are interpolated ghosts; the client never predicts enemy health) and mirrors ProjectileDamageSystem:
|
|
/// queue each swing, then collect ALL living enemies in the per-step cone (<see cref="MeleeConeMath"/>) ONCE, append
|
|
/// a SourceTick-stamped DamageEvent + stamp KnockbackState. All ticks via TickUtil.NonZero, compared with
|
|
/// NetworkTick only; feel knobs live in <see cref="TuningConfig"/> (MC-0, fallback to Defaults()).
|
|
/// </para>
|
|
/// </summary>
|
|
[UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
|
|
[UpdateAfter(typeof(PlayerControlSystem))]
|
|
[UpdateBefore(typeof(DashSystem))]
|
|
[BurstCompile]
|
|
public partial struct MeleeComboSystem : ISystem
|
|
{
|
|
ComponentLookup<KnockbackState> m_KnockbackLookup;
|
|
ComponentLookup<BossState> m_BossLookup; // A4: the boss is knockback-immune (no melee stunlock out of its slams)
|
|
|
|
ComponentLookup<RegionTag> m_RegionLookup;
|
|
BufferLookup<InventorySlot> m_InvLookup;
|
|
BufferLookup<StatModifier> m_StatModLookup;
|
|
|
|
[BurstCompile]
|
|
public void OnCreate(ref SystemState state)
|
|
{
|
|
m_KnockbackLookup = state.GetComponentLookup<KnockbackState>(isReadOnly: false);
|
|
m_BossLookup = state.GetComponentLookup<BossState>(isReadOnly: true);
|
|
|
|
m_RegionLookup = state.GetComponentLookup<RegionTag>(isReadOnly: true);
|
|
m_InvLookup = state.GetBufferLookup<InventorySlot>(isReadOnly: false);
|
|
m_StatModLookup = state.GetBufferLookup<StatModifier>(isReadOnly: true);
|
|
state.RequireForUpdate<NetworkTime>();
|
|
}
|
|
|
|
[BurstCompile]
|
|
public void OnUpdate(ref SystemState state)
|
|
{
|
|
if (!SystemAPI.TryGetSingleton<NetworkTime>(out var netTime) || !netTime.ServerTick.IsValid)
|
|
return;
|
|
var serverTick = netTime.ServerTick;
|
|
uint now = serverTick.TickIndexForValidTick;
|
|
|
|
var t = SystemAPI.TryGetSingleton<TuningConfig>(out var tc) ? tc : TuningConfig.Defaults();
|
|
float baseDamage = math.max(0f, t.MeleeDamage);
|
|
float baseRange = math.max(0f, t.MeleeRange);
|
|
float cosHalf = math.cos(math.max(0f, t.MeleeConeHalfAngleRad));
|
|
uint recoverTicks = (uint)math.max(1f, t.MeleeRecoverTicks);
|
|
uint graceTicks = (uint)math.max(1f, t.MeleeChainGraceTicks);
|
|
float moveScale = math.max(0f, t.MeleeSwingMoveScale);
|
|
float knockSpeed = math.max(0f, t.MeleeKnockbackSpeed);
|
|
float finisherMult = math.max(1f, t.MeleeFinisherMult);
|
|
byte comboLen = (byte)math.clamp((int)t.MeleeComboLength, 1, 3);
|
|
uint stamp = TickUtil.NonZero(now);
|
|
uint knockUntil = TickUtil.NonZero(now + (uint)math.max(1, Tuning.KnockbackDurationTicks));
|
|
|
|
bool isServer = state.WorldUnmanaged.IsServer();
|
|
|
|
// Server-only queue of cleaves to resolve after the player loop (so enemies are gathered ONCE, and only
|
|
// when at least one swing actually started — no per-tick enemy gather on idle/client ticks).
|
|
var cleaves = isServer ? new NativeList<PendingCleave>(Allocator.Temp) : default;
|
|
m_StatModLookup.Update(ref state); // Slice 2: per-player melee stat fold (read inside the player loop)
|
|
|
|
foreach (var (mc, control, input, facing, xform, owner, ds, entity) in
|
|
SystemAPI.Query<RefRW<MeleeCombo>, RefRW<CharacterControl>, RefRO<PlayerInput>,
|
|
RefRO<PlayerFacing>, RefRO<LocalTransform>, RefRO<GhostOwner>, RefRO<DashState>>()
|
|
.WithAll<Simulate>().WithDisabled<Dead>().WithEntityAccess())
|
|
{
|
|
// A dash window (i-frame OR recovery) active = dash owns movement + blocks a swing start (dash-cancel).
|
|
bool dashActive = ds.ValueRO.StartTick != 0u
|
|
&& !new NetworkTick(ds.ValueRO.StartTick).IsNewerThan(serverTick)
|
|
&& ds.ValueRO.RecoverUntilTick != 0u
|
|
&& new NetworkTick(ds.ValueRO.RecoverUntilTick).IsNewerThan(serverTick);
|
|
|
|
// Locked: mid swing / recovery (now < LockUntilTick).
|
|
bool locked = mc.ValueRO.LockUntilTick != 0u
|
|
&& new NetworkTick(mc.ValueRO.LockUntilTick).IsNewerThan(serverTick);
|
|
|
|
// --- ADVANCE (idempotent ABSOLUTE writes; dash wins same-tick ties via !Dash.IsSet) ---
|
|
bool swingStarted = false;
|
|
byte swingStep = 0;
|
|
if (input.ValueRO.Attack.IsSet && !locked && !dashActive && !input.ValueRO.Dash.IsSet)
|
|
{
|
|
bool inChainWindow = false;
|
|
if (mc.ValueRO.LockUntilTick != 0u)
|
|
{
|
|
var deadline = new NetworkTick(TickUtil.NonZero(mc.ValueRO.LockUntilTick + graceTicks));
|
|
inChainWindow = deadline.IsValid && deadline.IsNewerThan(serverTick); // now < lock+grace (now >= lock since !locked)
|
|
}
|
|
byte prev = mc.ValueRO.Step;
|
|
swingStep = (inChainWindow && prev >= 1 && prev < comboLen) ? (byte)(prev + 1) : (byte)1;
|
|
|
|
bool isFin = swingStep >= comboLen;
|
|
uint stepRecover = isFin ? (uint)math.max(1f, math.round(recoverTicks * finisherMult)) : recoverTicks;
|
|
|
|
mc.ValueRW.Step = swingStep;
|
|
mc.ValueRW.SwingStartTick = TickUtil.NonZero(now);
|
|
mc.ValueRW.LockUntilTick = TickUtil.NonZero(now + stepRecover);
|
|
swingStarted = true;
|
|
}
|
|
|
|
// --- MOVEMENT COMMIT (every pass; lower-bounded on SwingStartTick; DashSystem overrides later) ---
|
|
bool inSwingWindow = mc.ValueRO.SwingStartTick != 0u
|
|
&& !new NetworkTick(mc.ValueRO.SwingStartTick).IsNewerThan(serverTick)
|
|
&& mc.ValueRO.LockUntilTick != 0u
|
|
&& new NetworkTick(mc.ValueRO.LockUntilTick).IsNewerThan(serverTick);
|
|
if (inSwingWindow && !dashActive)
|
|
control.ValueRW.MoveVelocity *= moveScale;
|
|
|
|
// --- SERVER: queue the cleave (resolved after the loop). Damage/cone are SERVER-authoritative. ---
|
|
if (swingStarted && isServer)
|
|
{
|
|
bool isFin = swingStep >= comboLen;
|
|
// Slice 2: fold the player's class/run StatModifiers onto the live-tunable melee base so the
|
|
// PRIMARY verb scales with class identity (Warrior +MeleeDamage/+reach) + run augments.
|
|
bool hasMods = m_StatModLookup.HasBuffer(entity);
|
|
float pDamage = math.max(0f, hasMods ? StatMath.Apply(baseDamage, StatTarget.MeleeDamage, m_StatModLookup[entity]) : baseDamage);
|
|
float pRange = math.max(0f, hasMods ? StatMath.Apply(baseRange, StatTarget.MeleeRange, m_StatModLookup[entity]) : baseRange);
|
|
float2 face = facing.ValueRO.Direction;
|
|
face = math.lengthsq(face) < 1e-6f ? new float2(0f, 1f) : math.normalize(face);
|
|
cleaves.Add(new PendingCleave
|
|
{
|
|
From = xform.ValueRO.Position,
|
|
Face = face,
|
|
Damage = isFin ? pDamage * finisherMult : pDamage,
|
|
Range = isFin ? pRange * finisherMult : pRange,
|
|
KnockSpeed = isFin ? knockSpeed * finisherMult : knockSpeed,
|
|
OwnerId = owner.ValueRO.NetworkId,
|
|
Stamp = stamp,
|
|
KnockUntil = knockUntil,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Resolve queued cleaves SERVER-ONLY and only when one actually fired: gather living enemies ONCE, then
|
|
// append a SourceTick-stamped DamageEvent + stamp KnockbackState for each enemy in each swing's cone.
|
|
if (isServer && cleaves.IsCreated && cleaves.Length > 0)
|
|
{
|
|
var enemyEntities = new NativeList<Entity>(Allocator.Temp);
|
|
var enemyPositions = new NativeList<float3>(Allocator.Temp);
|
|
foreach (var (xform, health, enemyEntity) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>>()
|
|
.WithAll<EnemyTag>()
|
|
.WithEntityAccess())
|
|
{
|
|
if (health.ValueRO.Current <= 0f)
|
|
continue; // skip already-dead enemies (about to despawn)
|
|
enemyEntities.Add(enemyEntity);
|
|
enemyPositions.Add(xform.ValueRO.Position);
|
|
}
|
|
// Gather harvest targets (resource nodes + Blight clutter) ONCE so "any attack harvests": a swing
|
|
// depletes every node/clutter in its cone, crediting the shared ResourceLedger (the build currency
|
|
// pool) just like a base projectile hit. SERVER-ONLY (this whole block) — interpolated node ghosts
|
|
// are never rolled back, so the deposit + destroy fire exactly once per swing.
|
|
bool haveLedger = SystemAPI.TryGetSingletonEntity<ResourceLedger>(out var ledgerEntity);
|
|
bool haveDb = SystemAPI.TryGetSingleton<ItemDatabase>(out var itemDb);
|
|
DynamicBuffer<StorageEntry> ledger = default;
|
|
if (haveLedger) ledger = SystemAPI.GetBuffer<StorageEntry>(ledgerEntity);
|
|
m_RegionLookup.Update(ref state);
|
|
m_InvLookup.Update(ref state);
|
|
var meleePlayerByConn = new NativeHashMap<int, Entity>(8, Allocator.Temp);
|
|
foreach (var (po, pe) in SystemAPI.Query<RefRO<GhostOwner>>().WithAll<PlayerTag, InventorySlot>().WithEntityAccess())
|
|
meleePlayerByConn[po.ValueRO.NetworkId] = pe;
|
|
var harvEntity = new NativeList<Entity>(Allocator.Temp);
|
|
var harvPos = new NativeList<float3>(Allocator.Temp);
|
|
var harvRemaining = new NativeList<int>(Allocator.Temp);
|
|
var harvYieldId = new NativeList<byte>(Allocator.Temp);
|
|
var harvPerHit = new NativeList<float>(Allocator.Temp);
|
|
var harvIsClutter = new NativeList<bool>(Allocator.Temp);
|
|
var harvVariant = new NativeList<byte>(Allocator.Temp);
|
|
var harvToLedger = new NativeList<bool>(Allocator.Temp);
|
|
foreach (var (hx, node, he) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<ResourceNode>>().WithEntityAccess())
|
|
{
|
|
harvEntity.Add(he);
|
|
harvPos.Add(hx.ValueRO.Position);
|
|
harvRemaining.Add(node.ValueRO.Remaining);
|
|
harvYieldId.Add(node.ValueRO.ResourceId);
|
|
harvPerHit.Add(node.ValueRO.HarvestPerHit);
|
|
harvIsClutter.Add(false);
|
|
harvVariant.Add(0);
|
|
harvToLedger.Add(m_RegionLookup.HasComponent(he) && m_RegionLookup[he].Region == RegionId.Base);
|
|
}
|
|
foreach (var (hx, clutter, he) in
|
|
SystemAPI.Query<RefRO<LocalTransform>, RefRO<BlightClutter>>().WithEntityAccess())
|
|
{
|
|
harvEntity.Add(he);
|
|
harvPos.Add(hx.ValueRO.Position);
|
|
harvRemaining.Add(clutter.ValueRO.Remaining);
|
|
harvYieldId.Add(clutter.ValueRO.ScrapResourceId);
|
|
harvPerHit.Add(clutter.ValueRO.ScrapPerHit);
|
|
harvIsClutter.Add(true);
|
|
harvVariant.Add(clutter.ValueRO.Variant);
|
|
harvToLedger.Add(m_RegionLookup.HasComponent(he) && m_RegionLookup[he].Region == RegionId.Base);
|
|
}
|
|
var harvDestroyed = new NativeArray<bool>(harvEntity.Length, Allocator.Temp);
|
|
|
|
|
|
m_KnockbackLookup.Update(ref state);
|
|
m_BossLookup.Update(ref state);
|
|
|
|
var ecb = new EntityCommandBuffer(Allocator.Temp);
|
|
for (int s = 0; s < cleaves.Length; s++)
|
|
{
|
|
var c = cleaves[s];
|
|
for (int i = 0; i < enemyEntities.Length; i++)
|
|
{
|
|
if (!MeleeConeMath.InCone(c.From, c.Face, c.Range, cosHalf, enemyPositions[i]))
|
|
continue;
|
|
var target = enemyEntities[i];
|
|
ecb.AppendToBuffer(target, new DamageEvent
|
|
{
|
|
Amount = c.Damage,
|
|
SourceNetworkId = c.OwnerId,
|
|
SourceTick = c.Stamp,
|
|
});
|
|
if (c.KnockSpeed > 0f)
|
|
KnockbackUtil.Stamp(ref m_KnockbackLookup, m_BossLookup, target,
|
|
c.From, enemyPositions[i], c.Face, c.KnockSpeed, c.KnockUntil);
|
|
}
|
|
}
|
|
// HARVEST: deplete every node/clutter in each swing's cone, crediting the shared ledger; write
|
|
// Remaining back so the [GhostField] replicates -> WorldFeedbackSystem chips fire on melee mining.
|
|
for (int s = 0; s < cleaves.Length; s++)
|
|
{
|
|
var hc = cleaves[s];
|
|
for (int i = 0; i < harvEntity.Length; i++)
|
|
{
|
|
if (harvDestroyed[i])
|
|
continue;
|
|
if (!MeleeConeMath.InCone(hc.From, hc.Face, hc.Range, cosHalf, harvPos[i]))
|
|
continue;
|
|
|
|
int amount = math.max(1, (int)harvPerHit[i]);
|
|
byte yieldId = harvYieldId[i];
|
|
// Route by region: Base nodes credit the shared ledger DIRECTLY (the build pool); an
|
|
// expedition / un-tagged target goes to the swinging player's PERSONAL inventory (spill to
|
|
// ledger), mirroring ResourceHarvestSystem. Only deplete if the yield landed somewhere —
|
|
// never consume a node for zero credit (e.g. no ledger singleton present).
|
|
Entity meleeHarvester = Entity.Null;
|
|
if (meleePlayerByConn.TryGetValue(hc.OwnerId, out var meleePlayer))
|
|
meleeHarvester = meleePlayer;
|
|
bool deposited = HarvestMath.DepositYield(yieldId, amount, harvToLedger[i], meleeHarvester,
|
|
m_InvLookup, ledger, haveLedger, haveDb, itemDb);
|
|
if (!deposited)
|
|
continue;
|
|
|
|
int rem = harvRemaining[i] - amount;
|
|
harvRemaining[i] = rem;
|
|
if (rem <= 0)
|
|
{
|
|
harvDestroyed[i] = true;
|
|
ecb.DestroyEntity(harvEntity[i]);
|
|
}
|
|
else if (harvIsClutter[i])
|
|
{
|
|
ecb.SetComponent(harvEntity[i], new BlightClutter
|
|
{
|
|
Remaining = rem,
|
|
Variant = harvVariant[i],
|
|
ScrapResourceId = yieldId,
|
|
ScrapPerHit = harvPerHit[i],
|
|
});
|
|
}
|
|
else
|
|
{
|
|
ecb.SetComponent(harvEntity[i], new ResourceNode
|
|
{
|
|
ResourceId = yieldId,
|
|
Remaining = rem,
|
|
HarvestPerHit = harvPerHit[i],
|
|
});
|
|
}
|
|
}
|
|
}
|
|
ecb.Playback(state.EntityManager);
|
|
ecb.Dispose();
|
|
enemyEntities.Dispose();
|
|
enemyPositions.Dispose();
|
|
harvEntity.Dispose();
|
|
harvPos.Dispose();
|
|
harvRemaining.Dispose();
|
|
harvYieldId.Dispose();
|
|
harvPerHit.Dispose();
|
|
harvIsClutter.Dispose();
|
|
harvVariant.Dispose();
|
|
harvDestroyed.Dispose();
|
|
harvToLedger.Dispose();
|
|
meleePlayerByConn.Dispose();
|
|
}
|
|
|
|
if (cleaves.IsCreated)
|
|
cleaves.Dispose();
|
|
}
|
|
}
|
|
}
|