Merge eureka/aetheria-release-lock-warning: a painted ship owns a typed incoming-lock warning

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Assets/Scripts/Gameplay/ActionGameManager.cs

@@ -157,6 +157,8 @@ public class ActionGameManager : MonoBehaviour
     public Prototype FriendlyTargetIndicator;
     public PlaceUIElementWorldspace ViewDot;
     public Prototype LockIndicator;
+    // Presentation tuning: how far from the ship, toward the locker, the incoming-lock indicator sits.
+    public float IncomingLockIndicatorDistance = 30;
     public PlaceUIElementWorldspace[] Crosshairs;
     public GameObject HitMarker;
     public float HitMarkerDuration;
@@ -195,6 +197,7 @@ public class ActionGameManager : MonoBehaviour
     private TextMeshProUGUI _faceAimMark;
     private (HardpointData[] hardpoints, Transform[] barrels, PlaceUIElementWorldspace crosshair)[] _articulationGroups;
     private (LockWeapon targetLock, PlaceUIElementWorldspace indicator, Rotate spin)[] _lockingIndicators;
+    private (PlaceUIElementWorldspace indicator, Rotate spin) _incomingLockIndicator;
     private Dictionary<Entity, VisibleTargetIndicator> _visibleHostileIndicators = new Dictionary<Entity, VisibleTargetIndicator>();
     private Dictionary<Entity, VisibleTargetIndicator> _visibleFriendlyIndicators = new Dictionary<Entity, VisibleTargetIndicator>();
     private List<IDisposable> _shipSubscriptions = new List<IDisposable>();
@@ -999,6 +1002,8 @@ public class ActionGameManager : MonoBehaviour
         
         if(_lockingIndicators!=null) foreach(var (_, indicator, _) in _lockingIndicators)
             indicator.GetComponent<Prototype>().ReturnToPool();
+        if(_incomingLockIndicator.indicator != null) _incomingLockIndicator.indicator.GetComponent<Prototype>().ReturnToPool();
+        _incomingLockIndicator = default;
         DisablePlayerInput();
         Cursor.lockState = CursorLockMode.None;
         GameplayUI.gameObject.SetActive(false);
@@ -1142,6 +1147,10 @@ public class ActionGameManager : MonoBehaviour
                 var i = LockIndicator.Instantiate<PlaceUIElementWorldspace>();
                 return (x, i, i.GetComponent<Rotate>());
             }).ToArray();
+
+        var incoming = LockIndicator.Instantiate<PlaceUIElementWorldspace>();
+        incoming.gameObject.SetActive(false);
+        _incomingLockIndicator = (incoming, incoming.GetComponent<Rotate>());
     }
 
     private void UpdatePlayerPanel()
@@ -1444,11 +1453,33 @@ public class ActionGameManager : MonoBehaviour
             if(showLockingIndicator)
             {
                 indicator.Target = CurrentEntity.Target.Value.Entity.Position.ToUnity();
-                indicator.NoiseAmplitude = Settings.GameplaySettings.LockIndicatorNoiseAmplitude * (1 - targetLock.Lock);
-                indicator.NoiseFrequency = Settings.GameplaySettings.LockIndicatorFrequency.Evaluate(targetLock.Lock);
-                spin.Speed = Settings.GameplaySettings.LockSpinSpeed.Evaluate(targetLock.Lock);
+                ApplyLockProgress(indicator, spin, targetLock.Lock);
             }
         }
+
+        // The strongest lock on the player's ship, read only from IncomingLocks (never another ship's LockWeapon).
+        // Same curves as the outgoing indicator, driven by the warning's Strength.
+        var warnings = CurrentEntity.IncomingLocks;
+        var strongest = -1;
+        for (var w = 0; w < warnings.Count; w++)
+            if (strongest < 0 || warnings[w].Strength > warnings[strongest].Strength) strongest = w;
+        var (incomingIndicator, incomingSpin) = _incomingLockIndicator;
+        incomingIndicator.gameObject.SetActive(strongest >= 0);
+        if (strongest >= 0)
+        {
+            var warning = warnings[strongest];
+            incomingIndicator.Target = CurrentEntity.Position.ToUnity() +
+                new Vector3(warning.Bearing.x, 0, warning.Bearing.y) * IncomingLockIndicatorDistance;
+            ApplyLockProgress(incomingIndicator, incomingSpin, warning.Strength);
+        }
+    }
+
+    // The one lock-indicator curve: outgoing (the player's own lock) and incoming (the warning's strength) both tighten through it.
+    private void ApplyLockProgress(PlaceUIElementWorldspace indicator, Rotate spin, float progress)
+    {
+        indicator.NoiseAmplitude = Settings.GameplaySettings.LockIndicatorNoiseAmplitude * (1 - progress);
+        indicator.NoiseFrequency = Settings.GameplaySettings.LockIndicatorFrequency.Evaluate(progress);
+        spin.Speed = Settings.GameplaySettings.LockSpinSpeed.Evaluate(progress);
     }
 }
 

Assets/Scripts/ServerShared/Behaviors/LockWeapon.cs

@@ -102,6 +102,7 @@ public class LockWeapon : InstantWeapon
             {
                 var lerp = 1 - unlerp(0, 90, degrees);
                 _lock = saturate(_lock + pow(lerp, DirectionImpact) * dt * LockSpeed * pow(Entity.EntityInfoGathered[target], SensorImpact));
+                target.ReceivePaint(Entity.Position, Item?.Data, Lock);
             }
             else _lock = saturate(_lock - dt * Decay);
         }
@@ -110,3 +111,18 @@ public class LockWeapon : InstantWeapon
     }
 }
 
+// What a painted ship senses of one beam on it (ruling sensor-stat-set item 4; strength per ruling
+// lock-warning-strength). Strength is the emitter's own lock progress at the paint, 0..1, never summed.
+public readonly struct LockWarning
+{
+    public readonly float2 Bearing;
+    public readonly EquippableItemData EmitterClass;
+    public readonly float Strength;
+
+    public LockWarning(float2 bearing, EquippableItemData emitterClass, float strength)
+    {
+        Bearing = bearing;
+        EmitterClass = emitterClass;
+        Strength = strength;
+    }
+}

Assets/Scripts/ServerShared/Entity.cs

@@ -173,6 +173,12 @@ public abstract class Entity
     public Subject<Unit> HypothermiaDeath = new Subject<Unit>();
     public Subject<Entity> TargetedBy = new Subject<Entity>();
     public ReactiveProperty<int> TargetedByCount = new ReactiveProperty<int>(0);
+    // TargetedBy counts selection, which emits nothing; a lock warning comes only from a paint. LockWeapon.Execute
+    // reports each tick it paints this ship into the inbox; Update publishes the inbox once, so a warning lives
+    // exactly one tick after its last paint.
+    private readonly List<LockWarning> _paintInbox = new List<LockWarning>();
+    private readonly List<LockWarning> _incomingLocks = new List<LockWarning>();
+    public IReadOnlyList<LockWarning> IncomingLocks => _incomingLocks;
     public ReactiveProperty<SecurityLevel> CurrentSecurityLevel = new ReactiveProperty<SecurityLevel>(SecurityLevel.Open);
     public ReadOnlyReactiveProperty<bool> PresencePermitted;
     
@@ -783,6 +789,25 @@ public abstract class Entity
         VisibleEntities.Clear();
         VisibleEnemies.Clear();
         VisibleFriendlies.Clear();
+        _paintInbox.Clear();
+        _incomingLocks.Clear();
+    }
+
+    // Zone.Update runs this on every entity before any entity updates, so a paint made during tick N is published
+    // at the start of tick N+1 whatever order the emitter and this ship update in; a paint that stops is gone
+    // one tick later for every ordering.
+    internal void PublishPaints()
+    {
+        _incomingLocks.Clear();
+        _incomingLocks.AddRange(_paintInbox);
+        _paintInbox.Clear();
+    }
+
+    // The only caller is LockWeapon.Execute; strength is the emitter's own Lock at that paint.
+    internal void ReceivePaint(float3 emitterPosition, EquippableItemData emitterClass, float strength)
+    {
+        if (!_active) return;
+        _paintInbox.Add(new LockWarning(normalize((emitterPosition - Position).xz), emitterClass, strength));
     }
 
     public Entity(ItemManager itemManager, Zone zone, EquippableItem hull, EntitySettings settings)

Assets/Scripts/ServerShared/Zone.cs

@@ -226,7 +226,9 @@ public class Zone
         foreach(var agent in Agents)
             agent.Update(deltaTime);
 
-        foreach (var entity in Entities.ToArray()) entity.Update(deltaTime);
+        var entities = Entities.ToArray();
+        foreach (var entity in entities) entity.PublishPaints();
+        foreach (var entity in entities) entity.Update(deltaTime);
 
         StepMines(deltaTime);
         StepClouds(deltaTime);

tests/Aetheria.Shared.Tests/LockWarningTests.cs

@@ -0,0 +1,353 @@
+using System;
+using System.IO;
+using System.Linq;
+using CultMath;
+using GameCult.Caching;
+using Xunit;
+using static CultMath.math;
+
+// A painted ship owns a typed incoming-lock warning (cut lock-warning; rulings sensor-stat-set item 4 and
+// lock-warning-strength). Every fixture drives the production path: a real LockWeapon in a real ship's gear
+// executes inside Zone.Update, and the zone publishes every ship's paints before any ship updates. A paint made
+// during tick N is therefore what IncomingLocks holds after tick N+1, whatever order the ships sit in the zone.
+public sealed class LockWarningTests : IDisposable
+{
+    private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-lockwarn-" + Guid.NewGuid().ToString("N"));
+    private string Catalog => Path.Combine(_root, "Aetheria.cc");
+    private static readonly int2 HardpointCell = new int2(0, 0);
+    private CultCache _openCache;
+    private ItemManager _items;
+    private Zone _zone;
+
+    public LockWarningTests()
+    {
+        Directory.CreateDirectory(_root);
+        using (var cache = AetheriaStores.Open(Catalog, catalogWritable: true))
+        {
+            cache.Upsert(new VerseGrammar { Revision = 1 });
+            var hullShape = new Shape(3, 3);
+            foreach (var cell in hullShape.AllCoordinates) hullShape[cell] = true;
+            cache.Upsert(new HullData
+            {
+                Name = "Skiff", HullType = HullType.Ship, Shape = hullShape, Durability = 1000, Mass = 1000,
+                Hardpoints = { new HardpointData { Type = HardpointType.Sensors, Position = HardpointCell, Shape = new Shape() } }
+            });
+            cache.Upsert(Launcher("Launcher", lockSpeed: .6f, sensorImpact: 1, lockAngle: 30, directionImpact: 1));
+            cache.Upsert(Launcher("SkewLauncher", lockSpeed: .8f, sensorImpact: 3, lockAngle: 45, directionImpact: 2));
+            cache.FlushAsync().Wait();
+        }
+
+        _openCache = AetheriaStores.Open(Catalog, catalogWritable: true);
+        var ledger = new ProvenanceLedger();
+        for (var lot = 1; lot < 12; lot++) ledger.Lots[lot] = new Lot { Origin = new Attributed(), Quality = 1 };
+        _items = new ItemManager(_openCache, ledger, new GameplaySettings
+        {
+            DefaultEntitySettings = new EntitySettings(),
+            Tiers = new[] { new RarityTier { Name = "Common", Quality = .5f, Rarity = 0, Color = new float3(1, 1, 1) } },
+            QualityPriceModifier = new ExponentialLerp(),
+            TargetDetectionInfoThreshold = .1f,
+            TargetArmorInfoThreshold = .2f,
+            TargetGearInfoThreshold = .8f,
+            FiringArc = 170,
+            CommitHorizon = .5f,
+            SchematicCellSize = 1f,
+            UnaidedAccuracy = .05f,
+            UnaidedTracking = 10f,
+            UnaidedPrecision = 2f,
+            AgentMinHitProbability = 0f,
+            BeamResolveInterval = .1f
+        }, _ => { });
+        _zone = new Zone(_items, new PlanetSettings(), new ZonePack(), new GalaxyZone { Name = "Test Zone", Owner = null }, null);
+    }
+
+    public void Dispose()
+    {
+        _openCache?.Dispose();
+        Directory.Delete(_root, true);
+    }
+
+    private static PerformanceStat Const(float v) => new PerformanceStat { Min = v, Max = v };
+
+    private static GearData Launcher(string name, float lockSpeed, float sensorImpact, float lockAngle, float directionImpact) => new GearData
+    {
+        Name = name, Hardpoint = HardpointType.Sensors, Shape = new Shape(), Durability = 1,
+        MinimumTemperature = -1000, MaximumTemperature = 1000, OptimalTemperature = 0, PlateauWidth = 2000,
+        Behaviors =
+        {
+            new LauncherData // the production launcher type; the catalog round-trips it (a bare LockWeaponData is not a stored union member)
+            {
+                Damage = Const(0), Range = Const(1000), MinRange = Const(0), Velocity = Const(0),
+                Spread = Const(0), DamageSpread = Const(0), Penetration = Const(0), Count = Const(1),
+                BurstTime = Const(0), Cooldown = Const(1000),
+                DamageCurve = new BezierCurve { Keys = new[] { float4(0, 1, 0, 0), float4(1, 1, 0, 0) } },
+                LockSpeed = Const(lockSpeed), SensorImpact = Const(sensorImpact), LockAngle = Const(lockAngle),
+                DirectionImpact = Const(directionImpact), Decay = Const(.1f)
+            }
+        }
+    };
+
+    private int _nextLot = 2;
+
+    private Ship NewShip(float3 position, string launcher = null)
+    {
+        var hullRef = _items.ItemData.RefOf<ItemData>(_items.ItemData.GetByName<HullData>("Skiff"));
+        var ship = new Ship(_items, _zone, new EquippableItem { Data = hullRef, Durability = 1000, Lot = 1 }, new EntitySettings())
+            { Faction = new Faction { Name = "F" + Guid.NewGuid().ToString("N") } };
+        if (launcher != null)
+        {
+            var gearRef = _items.ItemData.RefOf<ItemData>(_items.ItemData.GetByName<GearData>(launcher));
+            Assert.True(ship.TryEquip(new EquippableItem { Data = gearRef, Durability = 1, Lot = _nextLot++ }, HardpointCell));
+        }
+        _zone.Entities.Add(ship);
+        ship.Activate();
+        ship.Position = position;
+        _zone.Update(0f); // brings the gear online
+        return ship;
+    }
+
+    private static LockWeapon LauncherOf(Entity e) => e.GetBehavior<LockWeapon>();
+
+    private static EquippedItem GearOf(Entity e) => e.Equipment.Single(i => i.Behaviors.Any(b => b is LockWeapon));
+
+    // The locker targets `target`, hostile to it, aimed straight at it (or along `aim`). The next zone tick paints.
+    private static void Aim(Ship locker, Ship target, float3? aim = null, float info = 1f)
+    {
+        locker.SetIff(target, true);
+        locker.EntityInfoGathered[target] = info;
+        locker.SetTarget(target);
+        locker.Aim = aim ?? normalize(target.Position - locker.Position);
+    }
+
+    private void Tick(float dt) => _zone.Update(dt);
+
+    [Fact]
+    public void APaintedShipLearnsBearingClassAndStrength()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(3, 0, 4));
+        var launcher = LauncherOf(locker);
+
+        Aim(locker, b);
+        Tick(.5f);
+        Assert.Empty(b.IncomingLocks); // published at the start of the next tick
+        Assert.Equal(.3f, launcher.Lock, 4); // fixture: 0.6 speed * 0.5 s on a dead-on, fully sensed target
+        Tick(.5f);
+
+        var warning = Assert.Single(b.IncomingLocks);
+        Assert.Equal(-.6f, warning.Bearing.x, 4);
+        Assert.Equal(-.8f, warning.Bearing.y, 4);
+        Assert.Same(GearOf(locker).Data, warning.EmitterClass);
+        Assert.Equal(.3f, warning.Strength, 4);
+
+        // The strength follows the emitter's lock as it grows: a stale or scaled copy would not.
+        Assert.Equal(.6f, launcher.Lock, 4);
+        Tick(0f);
+        Assert.Equal(.6f, Assert.Single(b.IncomingLocks).Strength, 4);
+    }
+
+    // The whole range of strength is pinned, not its middle: lock = 0.6 * dt on a dead-on, fully sensed target.
+    [Theory]
+    [InlineData(.25f, .15f)]
+    [InlineData(1f, .6f)]
+    [InlineData(1.25f, .75f)]
+    [InlineData(1.5f, .9f)]
+    [InlineData(1.55f, .93f)]
+    [InlineData(1.6f, .96f)]
+    [InlineData(1.65f, .99f)]
+    public void StrengthIsTheLockAcrossItsWholeRange(float dt, float expectedLock)
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+
+        Aim(locker, b);
+        Tick(dt);
+        Assert.Equal(expectedLock, LauncherOf(locker).Lock, 4);
+        Tick(0f);
+
+        Assert.Equal(expectedLock, Assert.Single(b.IncomingLocks).Strength, 4);
+    }
+
+    // A saturated lock is a strength of exactly 1: the launcher's own Execute outside the zone tick, so that the
+    // zone's fire resolution does not run on the shot a full lock fires.
+    [Fact]
+    public void AFullLockIsAStrengthOfOne()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+
+        Aim(locker, b);
+        LauncherOf(locker).Execute(5f);
+        Tick(0f);
+
+        Assert.Equal(1f, Assert.Single(b.IncomingLocks).Strength, 4);
+    }
+
+    // The lock's progress terms: direction (lerp ^ DirectionImpact) and sensor info (info ^ SensorImpact), each
+    // with an exponent other than 1, aimed off-axis at a partly sensed target. Lock after dt = 1:
+    // 0.8 * (1 - 30/90)^2 * 0.8^3 = 0.18204.
+    [Fact]
+    public void TheLockGrowsByDirectionAndSensorTermsNotJustSpeed()
+    {
+        var locker = NewShip(float3(0, 0, 0), "SkewLauncher");
+        var b = NewShip(float3(0, 0, 9));
+        var thirtyOff = float3(sin(30f * .0174533f), 0, cos(30f * .0174533f));
+
+        Aim(locker, b, thirtyOff, info: .8f);
+        Tick(1f);
+        Assert.Equal(.18204f, LauncherOf(locker).Lock, 4);
+        Tick(0f);
+
+        Assert.Equal(.18204f, Assert.Single(b.IncomingLocks).Strength, 4);
+    }
+
+    // Dead on, the direction term is 1 and the sensor term alone scales the lock: 0.8 * 0.5^3 = 0.1.
+    [Fact]
+    public void TheSensorTermAloneScalesADeadOnLock()
+    {
+        var locker = NewShip(float3(0, 0, 0), "SkewLauncher");
+        var b = NewShip(float3(0, 0, 9));
+
+        Aim(locker, b, info: .5f);
+        Tick(1f);
+
+        Assert.Equal(.1f, LauncherOf(locker).Lock, 4);
+    }
+
+    [Fact]
+    public void APaintFromALockerItCannotSeeStillWarns()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+        b.EntityInfoGathered[locker] = 0;
+        Assert.DoesNotContain(locker, b.VisibleEnemies);
+
+        Aim(locker, b);
+        Tick(.5f);
+        Tick(0f);
+
+        Assert.Single(b.IncomingLocks);
+        Assert.DoesNotContain(locker, b.VisibleEnemies);
+    }
+
+    [Fact]
+    public void TargetedIsNotPainted()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+        var c = NewShip(float3(9, 0, 0));
+
+        // B is targeted but the launcher is aimed at C, far outside LockAngle of B.
+        locker.SetIff(b, true);
+        locker.SetIff(c, true);
+        locker.EntityInfoGathered[b] = 1;
+        locker.EntityInfoGathered[c] = 1;
+        locker.SetTarget(b);
+        locker.Aim = float3(1, 0, 0);
+        Tick(.5f);
+        Tick(0f);
+
+        Assert.Empty(b.IncomingLocks);
+        Assert.Empty(c.IncomingLocks); // C is aimed at but not the target: nothing paints it either
+    }
+
+    // A broken lock stops warning on the same tick whichever of the two ships the zone updates first.
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void AWarningEndsTwoTicksAfterItsLastPaintInEveryEntityOrder(bool receiverFirst)
+    {
+        Ship locker, b;
+        if (receiverFirst)
+        {
+            b = NewShip(float3(0, 0, 9));
+            locker = NewShip(float3(0, 0, 0), "Launcher");
+        }
+        else
+        {
+            locker = NewShip(float3(0, 0, 0), "Launcher");
+            b = NewShip(float3(0, 0, 9));
+        }
+        Assert.Equal(receiverFirst ? (Entity) b : locker, _zone.Entities[0]);
+
+        Aim(locker, b);
+        Tick(.5f);                    // tick 1: painted
+        Assert.Empty(b.IncomingLocks);
+        Tick(.5f);                    // tick 2: tick 1's paint published, painted again
+        Assert.Single(b.IncomingLocks);
+
+        locker.Aim = float3(0, 0, -1); // the lock breaks: decays, paints nothing
+        Tick(.5f);                    // tick 3: tick 2's paint published, nothing painted
+        Assert.Single(b.IncomingLocks);
+        Assert.True(LauncherOf(locker).Lock > 0f, "fixture: the lock decays, it does not vanish");
+        Tick(.5f);                    // tick 4: nothing to publish
+        Assert.Empty(b.IncomingLocks);
+    }
+
+    [Fact]
+    public void ARetargetedLockerNoLongerWarnsItsOldTarget()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+        var c = NewShip(float3(9, 0, 0));
+        var launcher = LauncherOf(locker);
+
+        Aim(locker, b);
+        Tick(.5f);
+        Tick(.5f);
+        Assert.Single(b.IncomingLocks);
+
+        Aim(locker, c); // retarget: aim at C
+        Tick(.5f);      // the lock restarts on C: 0.3
+        Tick(0f);       // tick after the retarget: B has nothing newer to publish
+
+        Assert.Empty(b.IncomingLocks);
+        Assert.Equal(.3f, Assert.Single(c.IncomingLocks).Strength, 4);
+        Assert.Equal(.3f, launcher.Lock, 4);
+    }
+
+    [Fact]
+    public void EachPainterIsItsOwnWarning()
+    {
+        var one = NewShip(float3(0, 0, 0), "Launcher");
+        var two = NewShip(float3(10, 0, 10), "Launcher");
+        var b = NewShip(float3(0, 0, 10));
+
+        Aim(one, b);                                       // dead on: 0.6 * 0.5 = 0.3
+        var twentyOff = float3(-cos(20f * .0174533f), 0, sin(20f * .0174533f));
+        Aim(two, b, twentyOff);                            // 20 degrees off: 0.3 * (1 - 20/90) = 0.23333
+        Tick(.5f);
+        Tick(0f);
+
+        Assert.Equal(2, b.IncomingLocks.Count);
+        var strengths = b.IncomingLocks.Select(w => w.Strength).OrderBy(s => s).ToArray();
+        Assert.Equal(.23333f, strengths[0], 4);
+        Assert.Equal(.3f, strengths[1], 4); // never summed
+        Assert.Equal(2, b.IncomingLocks.Select(w => (w.Bearing.x, w.Bearing.y)).Distinct().Count());
+    }
+
+    [Fact]
+    public void AnInactiveShipHoldsNoWarnings()
+    {
+        var locker = NewShip(float3(0, 0, 0), "Launcher");
+        var b = NewShip(float3(0, 0, 9));
+        Aim(locker, b);
+        Tick(.5f);
+        Tick(0f);
+        Assert.Single(b.IncomingLocks);
+
+        b.Deactivate();
+        Assert.Empty(b.IncomingLocks);
+
+        Tick(.5f); // painted while docked or dead
+        b.Activate();
+        Tick(0f);
+        Assert.Empty(b.IncomingLocks); // the paint received while inactive was never stored
+
+        // A paint still waiting in the inbox when the ship deactivates does not survive to the next activation.
+        Tick(.5f);
+        b.Deactivate();
+        b.Activate();
+        Tick(0f);
+        Assert.Empty(b.IncomingLocks);
+    }
+}