PickupTests builds the zone over a sun and a planet on a rail, asserts the field differs between the ship's point and the item's and between start and end of the run, and checks each grab event at the zone time it was published. DrawnPoseWiringVerify gets a sun and a planet near the pickup and mine, requires the field under each to move with the drawn time, and checks the pickup's y as well as the mine's. Not compiled or run yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
778 lines
35 KiB
C#
778 lines
35 KiB
C#
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using CultMath;
|
|
using GameCult.Caching;
|
|
using UniRx;
|
|
using Xunit;
|
|
using static CultMath.math;
|
|
using float2 = CultMath.float2;
|
|
using float3 = CultMath.float3;
|
|
using int2 = CultMath.int2;
|
|
|
|
// The tractor beam in the sim (aetheria-release cut loot-2): a Pickup behaviour spins its beam up in sim time and runs
|
|
// one timed grab of a floating item, ending in Zone.TryPickUp. Rulings: jettison-shared-floating-items,
|
|
// unity-presents-only-r3, sim-speed-presentation; the question loot-grab-release-cancels, built hold-required. Every
|
|
// grab here is run by Zone.Update ticking a ship's own gear: nothing calls the behaviour directly.
|
|
public sealed class PickupTests : IDisposable
|
|
{
|
|
private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-pickup-" + Guid.NewGuid().ToString("N"));
|
|
private readonly List<CultCache> _caches = new List<CultCache>();
|
|
|
|
public PickupTests() => Directory.CreateDirectory(_root);
|
|
|
|
public void Dispose()
|
|
{
|
|
foreach (var c in _caches) c.Dispose();
|
|
Directory.Delete(_root, true);
|
|
}
|
|
|
|
private static PerformanceStat Constant(float v) => new PerformanceStat { Min = v, Max = v };
|
|
|
|
private static Shape Solid(int w, int h)
|
|
{
|
|
var shape = new Shape(w, h);
|
|
foreach (var cell in shape.AllCoordinates) shape[cell] = true;
|
|
return shape;
|
|
}
|
|
|
|
private static PickupData Beam(float extend = .3f, float envelop = .2f, float pull = .5f) => new PickupData
|
|
{
|
|
Range = Constant(75), BeamRadius = Constant(25), GrabPower = Constant(.5f), SpinRate = Constant(2),
|
|
ExtendTime = Constant(extend), EnvelopTime = Constant(envelop), PullTime = Constant(pull)
|
|
};
|
|
|
|
private sealed class Lab
|
|
{
|
|
public ItemManager Items;
|
|
public Zone Zone;
|
|
public int Lot = 1;
|
|
|
|
public EquippableItem Make(string name) => new EquippableItem
|
|
{
|
|
Data = Items.ItemData.RefOf<ItemData>(Items.ItemData.GetByName<EquippableItemData>(name)), Durability = 1, Lot = Lot++
|
|
};
|
|
|
|
public SimpleCommodity Ore(int quantity) => new SimpleCommodity
|
|
{
|
|
Data = Items.ItemData.RefOf<ItemData>(Items.ItemData.GetByName<SimpleCommodityData>("Ore")), Quantity = quantity
|
|
};
|
|
}
|
|
|
|
// With `wells`, the zone has a sun (a parentless rail off the ship's side, strength 400) and a planet on a moving rail round
|
|
// it (strength 25), the field a floater layer is read against; without, the zone is flat and nothing pulls on anything.
|
|
private Lab Build(PickupData beam, float lifetime = 30f, bool wells = false)
|
|
{
|
|
var settings = 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, TargetGearInfoThreshold = .8f,
|
|
FiringArc = 170, CommitHorizon = .5f, SchematicCellSize = 1f,
|
|
UnaidedAccuracy = .05f, UnaidedTracking = 10f, UnaidedPrecision = 2f, AgentMinHitProbability = 0f,
|
|
LootDropProbability = 0, LootDropVelocity = 25, FloatingItemLifetime = lifetime,
|
|
ShipLayerHeight = 3f, FloaterLayerHeight = -1.5f
|
|
};
|
|
var cache = AetheriaStores.Open(Path.Combine(_root, Guid.NewGuid().ToString("N") + ".cc"), catalogWritable: true);
|
|
_caches.Add(cache);
|
|
cache.Upsert(new VerseGrammar { Revision = 1 });
|
|
cache.Upsert(new HullData { Name = "Skiff", HullType = HullType.Ship, Shape = Solid(5, 5), Durability = 1000000, Mass = 1000 });
|
|
cache.Upsert(new GearData
|
|
{
|
|
Name = "Tractor", Hardpoint = HardpointType.Tool, Shape = Solid(1, 1), Durability = 1,
|
|
MinimumTemperature = -1000, MaximumTemperature = 1000, OptimalTemperature = 0, PlateauWidth = 2000,
|
|
Behaviors = { beam }
|
|
});
|
|
cache.Upsert(new GearData
|
|
{
|
|
Name = "Spare", Hardpoint = HardpointType.Tool, Shape = Solid(1, 1), Durability = 1,
|
|
MinimumTemperature = -1000, MaximumTemperature = 1000, OptimalTemperature = 0, PlateauWidth = 2000
|
|
});
|
|
cache.Upsert(new GearData
|
|
{
|
|
Name = "Block", Hardpoint = HardpointType.Tool, Shape = Solid(2, 2), Durability = 1,
|
|
MinimumTemperature = -1000, MaximumTemperature = 1000, OptimalTemperature = 0, PlateauWidth = 2000
|
|
});
|
|
cache.Upsert(new CargoBayData { Name = "Crate", Shape = new Shape(), InteriorShape = Solid(4, 4), Durability = 4 });
|
|
cache.Upsert(new SimpleCommodityData { Name = "Ore", Shape = Solid(1, 1), MaxStack = 100 });
|
|
cache.FlushAsync().Wait();
|
|
|
|
var ledger = new ProvenanceLedger();
|
|
for (var i = 1; i <= 9000; i++) ledger.Lots[i] = new Lot { Origin = new Attributed(), Quality = 1 };
|
|
var items = new ItemManager(cache, ledger, settings, _ => { });
|
|
var pack = new ZonePack { Radius = 0 };
|
|
var curves = new PlanetSettings();
|
|
if (wells)
|
|
{
|
|
curves = new PlanetSettings
|
|
{
|
|
BodyRadius = new ExponentialCurve(),
|
|
WellStrength = new ExponentialCurve { Multiplier = 1f, Exponent = 1f },
|
|
RocheLimit = new ExponentialCurve { Constant = 2f }
|
|
};
|
|
var sunOrbit = cache.Upsert(new OrbitData { FixedPosition = float2(-50, 0) }).Key;
|
|
var planetOrbit = cache.Upsert(new OrbitData { Parent = new CultRecordRef<OrbitData>(sunOrbit), Distance = 60f, Phase = .3f }).Key;
|
|
pack.Radius = 5000f;
|
|
pack.Mass = 10000f;
|
|
pack.Orbits.Add(new CultRecordRef<OrbitData>(sunOrbit));
|
|
pack.Orbits.Add(new CultRecordRef<OrbitData>(planetOrbit));
|
|
pack.Planets.Add(new CultRecordRef<BodyData>(cache.Upsert(new PlanetData { Name = "Sun", Orbit = new CultRecordRef<OrbitData>(sunOrbit), Mass = 400f }).Key));
|
|
pack.Planets.Add(new CultRecordRef<BodyData>(cache.Upsert(new PlanetData { Name = "Planet", Orbit = new CultRecordRef<OrbitData>(planetOrbit), Mass = 25f }).Key));
|
|
}
|
|
var zone = new Zone(items, curves, pack, new GalaxyZone { Name = "Pickup", Owner = null }, null);
|
|
return new Lab { Items = items, Zone = zone };
|
|
}
|
|
|
|
// A ship with `bays` cargo bays (bays are equipped before the zone admits the ship), aimed along +x and
|
|
// (unless told otherwise) carrying the tractor beam.
|
|
private static Ship Spawn(Lab lab, float3 at, bool beam = true, int bays = 1)
|
|
{
|
|
var hull = lab.Items.ItemData.RefOf<ItemData>(lab.Items.ItemData.GetByName<HullData>("Skiff"));
|
|
var ship = new Ship(lab.Items, lab.Zone, new EquippableItem { Data = hull, Durability = 1000000, Lot = lab.Lot++ }, new EntitySettings());
|
|
for (var i = 0; i < bays; i++) Equip(ship, lab.Make("Crate"));
|
|
if (beam) Equip(ship, lab.Make("Tractor"));
|
|
lab.Zone.Admit(ship, piloted: false);
|
|
ship.Position = at;
|
|
ship.Aim = float3(1, 0, 0);
|
|
return ship;
|
|
}
|
|
|
|
private static void Equip(Ship ship, EquippableItem gear)
|
|
{
|
|
Assert.True(ship.TryFindSpace(gear, out var pos));
|
|
Assert.True(ship.TryEquip(gear, pos));
|
|
}
|
|
|
|
private static FloatingItem Drift(Lab lab, float x, float y, float2 velocity = default, int ore = 5) =>
|
|
lab.Zone.Release(lab.Ore(ore), float2(x, y), velocity);
|
|
|
|
private static List<GrabEvent> Watch(Entity ship, CompositeDisposable bag)
|
|
{
|
|
var events = new List<GrabEvent>();
|
|
ship.Capabilities.Grab.Subscribe(events.Add).AddTo(bag);
|
|
return events;
|
|
}
|
|
|
|
private static void Tick(Lab lab, int ticks, float dt)
|
|
{
|
|
for (var i = 0; i < ticks; i++) lab.Zone.Update(dt);
|
|
}
|
|
|
|
// Ticks until the condition holds, for at most twenty sim seconds; a grab that never comes fails here instead of hanging.
|
|
private static void Until(Lab lab, float dt, Func<bool> done)
|
|
{
|
|
for (var tick = 0; tick < 1200 && !done(); tick++) lab.Zone.Update(dt);
|
|
Assert.True(done(), "the expected moment never came");
|
|
}
|
|
|
|
private static void Kill(Entity e) => e.HeatstrokeDeath.OnNext(Unit.Default);
|
|
|
|
[Fact]
|
|
public void NoPickupBehaviourNoGrab()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
|
|
// The same ship and item, with and without the gear: only the gear grabs.
|
|
var bare = Build(Beam());
|
|
var plain = Spawn(bare, float3(0, 0, 0), beam: false);
|
|
var left = Drift(bare, 40, 0);
|
|
var plainEvents = Watch(plain, bag);
|
|
plain.TractorCommand = 1;
|
|
Tick(bare, 240, 1 / 60f);
|
|
Assert.True(left.Holder == null, "left is held");
|
|
Assert.True(bare.Zone.FloatingItems.Contains(left), "left left the zone");
|
|
Assert.Equal(0f, plain.TractorPower);
|
|
Assert.Empty(plainEvents);
|
|
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 60, 1 / 60f);
|
|
Assert.True(ReferenceEquals(ship, item.Holder), "item is not held by ship");
|
|
Assert.Equal(GrabPhase.Started, events.First().Phase);
|
|
Assert.True(ship.TractorPower > 0f);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(60)]
|
|
[InlineData(600)]
|
|
public void TheBeamSpinsUpInSimTime(int ticksPerSecond)
|
|
{
|
|
var dt = 1f / ticksPerSecond;
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
|
|
// Power rises two per sim second and not faster, at any tick rate; the claim comes on the tick it passes GrabPower.
|
|
ship.TractorCommand = 1;
|
|
int claim = -1, full = -1;
|
|
var before = 0f;
|
|
for (var tick = 1; tick <= ticksPerSecond; tick++)
|
|
{
|
|
lab.Zone.Update(dt);
|
|
if (claim < 0 && item.Holder != null)
|
|
{
|
|
claim = tick;
|
|
Assert.True(ship.TractorPower >= .5f);
|
|
Assert.True(before < .5f);
|
|
}
|
|
if (full < 0 && ship.TractorPower >= 1f) full = tick;
|
|
before = ship.TractorPower;
|
|
}
|
|
Assert.Equal(ticksPerSecond / 4, claim);
|
|
Assert.Equal(ticksPerSecond / 2, full);
|
|
|
|
// Command 0 spins it down at the same rate.
|
|
ship.TractorCommand = 0;
|
|
var empty = -1;
|
|
for (var tick = 1; tick <= ticksPerSecond; tick++)
|
|
{
|
|
lab.Zone.Update(dt);
|
|
if (empty < 0 && ship.TractorPower <= 0f) empty = tick;
|
|
}
|
|
Assert.Equal(ticksPerSecond / 2, empty);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(.3f, .2f, .5f, 60)]
|
|
[InlineData(1f, 1f, 1f, 180)]
|
|
public void AGrabTakesExactlyItsPhasesThenCommits(float extend, float envelop, float pull, int ticksAfterClaim)
|
|
{
|
|
foreach (var rate in new[] { 60, 600 })
|
|
{
|
|
var dt = 1f / rate;
|
|
var lab = Build(Beam(extend, envelop, pull));
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
ship.TractorCommand = 1;
|
|
int claim = -1, commit = -1;
|
|
for (var tick = 1; tick <= rate * 6 && commit < 0; tick++)
|
|
{
|
|
lab.Zone.Update(dt);
|
|
if (claim < 0 && item.Holder != null) claim = tick;
|
|
if (!lab.Zone.FloatingItems.Contains(item)) commit = tick;
|
|
}
|
|
Assert.True(claim > 0);
|
|
Assert.Equal(ticksAfterClaim * rate / 60, commit - claim);
|
|
Assert.Equal(5, ship.CargoBays.Single().Cargo.Keys.OfType<SimpleCommodity>().Single().Quantity);
|
|
}
|
|
}
|
|
|
|
// The beam ends on the loot where the loot is drawn: the field plus the floater layer, not the grabbing ship's plane
|
|
// (ruling orbitals-above-floaters-below).
|
|
[Fact]
|
|
public void AGrabPointRidesTheFloaterLayerNotTheShips()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam(), wells: true);
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
|
|
// The fixture has a field to ride: it differs between the ship's point and the item's, and between the start and
|
|
// the end of the run, so a grab point read at the ship's xz or at the wrong time cannot agree with it.
|
|
var atShip = lab.Zone.GetHeight(float2(0, 0), lab.Zone.ExactTime);
|
|
var atItem = lab.Zone.GetHeight(float2(40, 0), lab.Zone.ExactTime);
|
|
Assert.True(abs(atItem - atShip) > 1f, $"the field is flat under the grab: ship {atShip}, item {atItem}");
|
|
var start = lab.Zone.ExactTime;
|
|
|
|
// Each event is checked at the zone time it was published, where the sim read the field.
|
|
var seen = new List<(GrabEvent Event, double Time)>();
|
|
ship.Capabilities.Grab.Subscribe(e => seen.Add((e, lab.Zone.ExactTime))).AddTo(bag);
|
|
ship.TractorCommand = 1;
|
|
for (var tick = 1; tick <= 150; tick++) lab.Zone.Update(1 / 60f);
|
|
Assert.NotEmpty(seen);
|
|
Assert.True(abs(lab.Zone.GetHeight(float2(40, 0), lab.Zone.ExactTime) - lab.Zone.GetHeight(float2(40, 0), start)) > .01f, "the wells did not move");
|
|
Assert.All(seen, s => Assert.Equal(lab.Zone.GetHeight(s.Event.TargetPosition.xz, s.Time) - 1.5f, s.Event.TargetPosition.y, 3));
|
|
Assert.All(seen, s => Assert.True(abs(s.Event.TargetPosition.y - (-1.5f)) > 1f, "the grab point sits on the bare layer, the field dropped"));
|
|
}
|
|
|
|
[Fact]
|
|
public void GrabEventsNameTheFloatingItem()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var other = Drift(lab, 40, 20);
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
for (var tick = 1; tick <= 150; tick++) lab.Zone.Update(1 / 60f);
|
|
Assert.Equal(new[] { GrabPhase.Started, GrabPhase.Extend, GrabPhase.Envelop, GrabPhase.Pull, GrabPhase.Completed },
|
|
events.Take(5).Select(e => e.Phase).ToArray());
|
|
Assert.All(events.Take(5), e => Assert.Equal(item.Id, e.Target));
|
|
Assert.NotEqual(other.Id, item.Id);
|
|
Assert.Equal(.3f, events[1].PhaseDuration, 4);
|
|
Assert.Equal(.2f, events[2].PhaseDuration, 4);
|
|
Assert.Equal(.5f, events[3].PhaseDuration, 4);
|
|
}
|
|
|
|
// Each phase is published on the first tick at or after its boundary (.3, .5 and 1 s after the claim), at any
|
|
// tick rate or an uneven one. The clock is a float sum, so a boundary an exact number of ticks away can land one
|
|
// tick late (Envelop and Pull do at 1/600): the rule is "not before, at most one tick after", not a tick count.
|
|
[Theory]
|
|
[InlineData(1, 60, 60, 60, 60)]
|
|
[InlineData(1, 600, 600, 600, 600)]
|
|
[InlineData(4, 60, 24, 90, 33)]
|
|
public void EachPhaseFiresOnTheFirstTickAtOrAfterItsBoundary(int cycle, int a, int b, int c, int d)
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var rates = cycle == 1 ? new[] { a } : new[] { a, b, c, d };
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
var since = -1.0;
|
|
var times = new List<double>();
|
|
var steps = new List<double>();
|
|
for (var tick = 0; tick < rates.Length * 3000 && events.Count(e => e.Phase == GrabPhase.Completed) == 0; tick++)
|
|
{
|
|
var dt = 1f / rates[tick % rates.Length];
|
|
lab.Zone.Update(dt);
|
|
if (since >= 0) since += dt;
|
|
else if (events.Count > 0) since = 0;
|
|
while (times.Count < events.Count) { times.Add(since); steps.Add(dt); }
|
|
}
|
|
var phases = events.Select(e => e.Phase).ToList();
|
|
Assert.Equal(GrabPhase.Completed, phases.Last());
|
|
foreach (var (phase, boundary) in new[] { (GrabPhase.Envelop, .3), (GrabPhase.Pull, .5), (GrabPhase.Completed, 1.0) })
|
|
{
|
|
var i = phases.IndexOf(phase);
|
|
Assert.True(i >= 0, "the phase never came");
|
|
Assert.True(times[i] >= boundary - 1e-5, "the phase fired before its boundary");
|
|
// Where no tick lands exactly on a boundary (the uneven cycle) the tick before must be strictly short of it;
|
|
// on a regular grid the float sum may leave that tick a hair short, so it may be equal.
|
|
var slack = cycle == 1 ? 1e-5 : -1e-5;
|
|
Assert.True(times[i] - steps[i] < boundary + slack, "the phase fired after the first tick at or past its boundary");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ReleasingTheBeamCancelsAndTheItemFloatsFree()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
const float dt = 1 / 60f;
|
|
var lab = Build(Beam(), lifetime: 2f);
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0, float2(3, 1));
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
var tick = 0;
|
|
while (!events.Any(e => e.Phase == GrabPhase.Pull) && tick++ < 600) lab.Zone.Update(dt);
|
|
Assert.True(ReferenceEquals(ship, item.Holder), "item is not held by ship");
|
|
var velocity = item.Body.Velocity;
|
|
var drift = item.Body.Drift;
|
|
|
|
// The key comes up during the pull: Power falls below GrabPower and the grab is dropped.
|
|
ship.TractorCommand = 0;
|
|
while (!events.Any(e => e.Phase == GrabPhase.Cancelled) && tick++ < 600) lab.Zone.Update(dt);
|
|
Assert.True(tick < 110);
|
|
Assert.DoesNotContain(events, e => e.Phase == GrabPhase.Completed);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
Assert.True(lab.Zone.FloatingItems.Contains(item), "item left the zone");
|
|
// (It has taken the one step of its freeing tick, so it is the held velocity less a tick's drag.)
|
|
Assert.Equal(velocity.x, item.Body.Velocity.x, velocity.x * .01f);
|
|
Assert.Equal(velocity.y, item.Body.Velocity.y, velocity.y * .01f);
|
|
Assert.True(velocity.x > 1f);
|
|
|
|
// It drifts on with that velocity and expires on the clock it was released on, not from the cancel.
|
|
var at = item.Body.Position;
|
|
lab.Zone.Update(dt);
|
|
Assert.True(item.Body.Position.x > at.x);
|
|
while (lab.Zone.FloatingItems.Contains(item) && tick++ < 600) lab.Zone.Update(dt);
|
|
Assert.InRange(tick, 118, 122);
|
|
}
|
|
|
|
[Fact]
|
|
public void AHoldThatFillsMidGrabCancelsAtTheEnd()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var bay = ship.CargoBays.Single();
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Until(lab, 1 / 60f, () => item.Holder != null);
|
|
|
|
// The hold fills while the grab runs: the item slides in and then floats free.
|
|
for (var i = 0; i < 16; i++) Assert.True(bay.TryStore(lab.Make("Spare")));
|
|
var tick = 0;
|
|
while (!events.Any(e => e.Phase == GrabPhase.Cancelled) && tick++ < 300) lab.Zone.Update(1 / 60f);
|
|
Assert.Equal(new[] { GrabPhase.Started, GrabPhase.Extend, GrabPhase.Envelop, GrabPhase.Pull, GrabPhase.Cancelled },
|
|
events.Select(e => e.Phase).ToArray());
|
|
Assert.True(item.Holder == null, "item is held");
|
|
Assert.True(lab.Zone.FloatingItems.Contains(item), "item left the zone");
|
|
Assert.Equal(16, bay.Cargo.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void AFullHoldNeverClaimsWhatItCannotStore()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var bay = ship.CargoBays.Single();
|
|
for (var i = 0; i < 16; i++) Assert.True(bay.TryStore(lab.Make("Spare")));
|
|
var item = Drift(lab, 40, 0, float2(3, 1));
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 300, 1 / 60f);
|
|
Assert.Equal(1f, ship.TractorPower);
|
|
Assert.Empty(events);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
Assert.True(item.Body.Position.x > 40f, "item was pinned instead of drifting");
|
|
}
|
|
|
|
[Fact]
|
|
public void AnItemTheHoldCannotStoreDoesNotBlockOneItCan()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var bay = ship.CargoBays.Single();
|
|
for (var i = 0; i < 15; i++) Assert.True(bay.TryStore(lab.Make("Spare")));
|
|
// One free cell: the 2x2 block is nearest the axis and cannot be stored; the ore beside it can.
|
|
var block = lab.Zone.Release(lab.Make("Block"), float2(30, 0), default);
|
|
var ore = Drift(lab, 50, 10);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 150, 1 / 60f);
|
|
Assert.Contains(events, e => e.Phase == GrabPhase.Completed);
|
|
Assert.All(events, e => Assert.Equal(ore.Id, e.Target));
|
|
Assert.False(lab.Zone.FloatingItems.Contains(ore), "ore is still in the zone");
|
|
Assert.True(lab.Zone.FloatingItems.Contains(block), "block left the zone");
|
|
Assert.True(block.Holder == null, "block is held");
|
|
}
|
|
|
|
// Either bay may be the full one: a selection that read only the first bay, or only the last, fails one orientation.
|
|
[Theory]
|
|
[InlineData(0)]
|
|
[InlineData(1)]
|
|
public void TheBeamTakesFromWhicheverBayCanStore(int fullBay)
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0), bays: 2);
|
|
Assert.Equal(2, ship.CargoBays.Count);
|
|
var freeBay = 1 - fullBay;
|
|
for (var i = 0; i < 16; i++) Assert.True(ship.CargoBays[fullBay].TryStore(lab.Make("Spare")));
|
|
var ore = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 300, 1 / 60f);
|
|
Assert.Contains(events, e => e.Phase == GrabPhase.Started && e.Target.Equals(ore.Id));
|
|
Assert.Contains(events, e => e.Phase == GrabPhase.Completed);
|
|
Assert.False(lab.Zone.FloatingItems.Contains(ore), "ore is still in the zone");
|
|
Assert.Equal(16, ship.CargoBays[fullBay].Cargo.Count);
|
|
Assert.Single(ship.CargoBays[freeBay].Cargo);
|
|
}
|
|
|
|
[Fact]
|
|
public void AnItemInTheBeamsFarCornerIsCollected()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
// 74 along and 20 off the axis: inside the beam, though 76.7 from the ship, past Range as a straight distance.
|
|
var corner = Drift(lab, 74, 20);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 150, 1 / 60f);
|
|
Assert.DoesNotContain(events, e => e.Phase == GrabPhase.Cancelled);
|
|
Assert.Contains(events, e => e.Phase == GrabPhase.Completed);
|
|
Assert.False(lab.Zone.FloatingItems.Contains(corner), "corner is still in the zone");
|
|
}
|
|
|
|
[Fact]
|
|
public void AnItemLeavingTheBeamBeforeThePullIsCancelled()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Until(lab, 1 / 60f, () => item.Holder != null);
|
|
|
|
// The pilot swings the beam away while the grab extends: the item is off the axis and the grab is dropped.
|
|
ship.Aim = float3(0, 0, 1);
|
|
Tick(lab, 3, 1 / 60f);
|
|
Assert.Equal(GrabPhase.Cancelled, events.Last().Phase);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
}
|
|
|
|
[Fact]
|
|
public void OneHolderPerItem()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var a = Spawn(lab, float3(0, 0, 0));
|
|
var b = Spawn(lab, float3(0, 0, 10));
|
|
var eventsA = Watch(a, bag);
|
|
var eventsB = Watch(b, bag);
|
|
|
|
// One item, two beams: exactly one claims it, the other never does, and the non-holder cannot take it.
|
|
var only = Drift(lab, 40, 5);
|
|
a.TractorCommand = 1;
|
|
b.TractorCommand = 1;
|
|
Tick(lab, 20, 1 / 60f);
|
|
Assert.Equal(1, new[] { eventsA, eventsB }.Count(e => e.Any(x => x.Phase == GrabPhase.Started)));
|
|
var holder = only.Holder;
|
|
var loser = ReferenceEquals(holder, a) ? b : a;
|
|
Assert.False(lab.Zone.TryPickUp(loser, only.Id));
|
|
Assert.False(lab.Zone.TryHold(loser, only.Id));
|
|
Assert.True(lab.Zone.FloatingItems.Contains(only), "only left the zone");
|
|
Assert.Empty(loser.CargoBays.Single().Cargo);
|
|
Tick(lab, 120, 1 / 60f);
|
|
Assert.False(lab.Zone.FloatingItems.Contains(only), "only is still in the zone");
|
|
Assert.Single(holder.CargoBays.Single().Cargo);
|
|
Assert.Empty(loser.CargoBays.Single().Cargo);
|
|
|
|
// Two items, each nearest a different beam's axis: each ship holds its own.
|
|
var first = Drift(lab, 60, 0);
|
|
var second = Drift(lab, 60, 10);
|
|
Tick(lab, 20, 1 / 60f);
|
|
Assert.True(first.Holder != null, "first is free");
|
|
Assert.True(second.Holder != null, "second is free");
|
|
Assert.False(ReferenceEquals(first.Holder, second.Holder), "one holder for two items");
|
|
|
|
// Both ships' nearest item is the same one: the one that loses it takes the other.
|
|
var shared = Build(Beam());
|
|
var p = Spawn(shared, float3(0, 0, 0));
|
|
var q = Spawn(shared, float3(0, 0, 10));
|
|
var near = Drift(shared, 40, 5);
|
|
var far = Drift(shared, 40, -14);
|
|
p.TractorCommand = 1;
|
|
q.TractorCommand = 1;
|
|
Tick(shared, 20, 1 / 60f);
|
|
Assert.True(near.Holder != null, "near is free");
|
|
Assert.True(far.Holder != null, "far is free");
|
|
Assert.False(ReferenceEquals(near.Holder, far.Holder), "one holder for two items");
|
|
}
|
|
|
|
[Fact]
|
|
public void AGrabIsDroppedWhenItsGearGoesInactiveOrTheItemFallsOutOfRangeBeforeThePull()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
const float dt = 1 / 60f;
|
|
|
|
// Gear switched off mid-grab: cancelled, the item free.
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 30, dt);
|
|
Assert.True(ReferenceEquals(ship, item.Holder), "item is not held by ship");
|
|
ship.Equipment.Single(e => e.Behaviors.OfType<Pickup>().Any()).Enabled.Value = false;
|
|
Tick(lab, 2, dt);
|
|
Assert.Equal(GrabPhase.Cancelled, events.Last().Phase);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
|
|
// The ship leaves while the beam is still extending: cancelled. The same departure during the pull is not.
|
|
foreach (var departAtPull in new[] { false, true })
|
|
{
|
|
var other = Build(Beam());
|
|
var pilot = Spawn(other, float3(0, 0, 0));
|
|
var target = Drift(other, 40, 0);
|
|
var seen = Watch(pilot, bag);
|
|
pilot.TractorCommand = 1;
|
|
Until(other, dt, () => seen.Any(e => departAtPull ? e.Phase == GrabPhase.Pull : e.Phase == GrabPhase.Extend));
|
|
pilot.Position = float3(-200, 0, 0);
|
|
Tick(other, 120, dt);
|
|
if (departAtPull)
|
|
{
|
|
Assert.Equal(GrabPhase.Completed, seen.First(e => e.Phase == GrabPhase.Completed || e.Phase == GrabPhase.Cancelled).Phase);
|
|
Assert.False(other.Zone.FloatingItems.Contains(target), "target is still in the zone");
|
|
}
|
|
else
|
|
{
|
|
Assert.Equal(GrabPhase.Cancelled, seen.First(e => e.Phase == GrabPhase.Completed || e.Phase == GrabPhase.Cancelled).Phase);
|
|
Assert.True(target.Holder == null, "target is held");
|
|
Assert.True(other.Zone.FloatingItems.Contains(target), "target left the zone");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void SelectionIsTheItemNearestTheBeamAxis()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
|
|
// The nearer to the axis wins, though the other is closer to the ship.
|
|
var near = Drift(lab, 20, 12);
|
|
var onAxis = Drift(lab, 60, 3);
|
|
Tick(lab, 30, 1 / 60f);
|
|
Assert.True(ReferenceEquals(ship, onAxis.Holder), "onAxis is not held by ship");
|
|
Assert.True(near.Holder == null, "near is held");
|
|
Assert.Equal(onAxis.Id, events.First().Target);
|
|
|
|
// Out of the beam, past its range or behind the ship, an item is never taken.
|
|
foreach (var (x, y) in new[] { (30f, 30f), (80f, 0f), (-10f, 0f) })
|
|
{
|
|
var other = Build(Beam());
|
|
var lone = Spawn(other, float3(0, 0, 0));
|
|
var stray = Drift(other, x, y);
|
|
var attempts = Watch(lone, bag);
|
|
lone.TractorCommand = 1;
|
|
Tick(other, 240, 1 / 60f);
|
|
Assert.Empty(attempts);
|
|
Assert.True(stray.Holder == null, "stray is held");
|
|
Assert.True(other.Zone.FloatingItems.Contains(stray), "stray left the zone");
|
|
}
|
|
|
|
// Equally far from the axis, the lower id.
|
|
var tie = Build(Beam());
|
|
var pilot = Spawn(tie, float3(0, 0, 0));
|
|
var lower = Drift(tie, 40, 5);
|
|
var higher = Drift(tie, 40, -5);
|
|
pilot.TractorCommand = 1;
|
|
Tick(tie, 30, 1 / 60f);
|
|
Assert.True(ReferenceEquals(pilot, lower.Holder), "lower is not held by pilot");
|
|
Assert.True(higher.Holder == null, "higher is held");
|
|
}
|
|
|
|
[Fact]
|
|
public void AHeldItemIsPlacedNotIntegratedAndDoesNotExpire()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
const float dt = 1 / 60f;
|
|
var lab = Build(Beam(), lifetime: 1f);
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var item = Drift(lab, 40, 0, float2(3, 0));
|
|
var events = Watch(ship, bag);
|
|
ship.TractorCommand = 1;
|
|
Until(lab, dt, () => item.Holder != null);
|
|
var claimed = item.Body.Position;
|
|
Assert.Equal(claimed, item.HeldFrom);
|
|
|
|
// Through Extend and Envelop the item stays where it was claimed, whatever velocity it had.
|
|
for (var guard = 0; guard < 1200 && !events.Any(e => e.Phase == GrabPhase.Pull); guard++)
|
|
{
|
|
lab.Zone.Update(dt);
|
|
if (events.Any(e => e.Phase == GrabPhase.Pull)) break;
|
|
Assert.Equal(claimed, item.Body.Position);
|
|
}
|
|
Assert.Contains(events, e => e.Phase == GrabPhase.Pull);
|
|
|
|
// During the pull it moves toward the holder, and a held item outlives its lifetime.
|
|
lab.Zone.Update(dt * 10);
|
|
Assert.True(item.Body.Position.x < claimed.x);
|
|
Assert.True(item.Body.Position.x > 0);
|
|
var held = Build(Beam(), lifetime: 1f);
|
|
var carrier = Spawn(held, float3(5, 0, 7));
|
|
var stuck = Drift(held, 40, 0);
|
|
Assert.True(held.Zone.TryHold(carrier, stuck.Id));
|
|
Tick(held, 180, dt);
|
|
Assert.True(held.Zone.FloatingItems.Contains(stuck), "stuck left the zone");
|
|
Assert.Equal(float2(40, 0), stuck.Body.Position);
|
|
|
|
// The pose eases (smoothstep): a quarter of the progress is 15.625 per cent of the way, not 25.
|
|
held.Zone.SetHeldProgress(stuck.Id, .25f);
|
|
held.Zone.Update(dt);
|
|
Assert.Equal(40f - 35f * .15625f, stuck.Body.Position.x, 3);
|
|
Assert.Equal(7f * .15625f, stuck.Body.Position.y, 3);
|
|
|
|
// Placed, not drifted: the same progress held for two steps puts it at the same halfway point.
|
|
held.Zone.SetHeldProgress(stuck.Id, .5f);
|
|
held.Zone.Update(dt);
|
|
held.Zone.Update(dt);
|
|
Assert.Equal(22.5f, stuck.Body.Position.x, 3);
|
|
Assert.Equal(3.5f, stuck.Body.Position.y, 3);
|
|
|
|
// At progress 1 it is at the holder; freed, an item past its lifetime goes on the next step.
|
|
held.Zone.SetHeldProgress(stuck.Id, 1);
|
|
held.Zone.Update(dt);
|
|
Assert.Equal(5f, stuck.Body.Position.x, 3);
|
|
Assert.Equal(7f, stuck.Body.Position.y, 3);
|
|
held.Zone.Free(stuck.Id);
|
|
held.Zone.Update(dt);
|
|
Assert.False(held.Zone.FloatingItems.Contains(stuck), "stuck is still in the zone");
|
|
}
|
|
|
|
[Fact]
|
|
public void AnInactiveBeamSpinsDownAndMustSpinUpAgain()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
const float dt = 1 / 60f;
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
var gear = ship.Equipment.Single(e => e.Behaviors.OfType<Pickup>().Any());
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 60, dt);
|
|
Assert.Equal(1f, ship.TractorPower);
|
|
|
|
// Switched off with the key still down, the beam spins down at the spin rate...
|
|
gear.Enabled.Value = false;
|
|
Tick(lab, 15, dt);
|
|
Assert.InRange(ship.TractorPower, .45f, .55f);
|
|
Tick(lab, 30, dt);
|
|
Assert.Equal(0f, ship.TractorPower);
|
|
|
|
// ...and switched back on it spins up from nothing: an item in the beam is not claimed at once.
|
|
var item = Drift(lab, 40, 0);
|
|
var events = Watch(ship, bag);
|
|
gear.Enabled.Value = true;
|
|
Tick(lab, 10, dt);
|
|
Assert.Empty(events);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
Tick(lab, 20, dt);
|
|
Assert.True(ReferenceEquals(ship, item.Holder), "item is not held by ship");
|
|
}
|
|
|
|
[Fact]
|
|
public void RemovingOneHolderFreesOnlyItsOwnItems()
|
|
{
|
|
var lab = Build(Beam());
|
|
var a = Spawn(lab, float3(0, 0, 0));
|
|
var b = Spawn(lab, float3(0, 0, 50));
|
|
var mine = Drift(lab, 40, 0);
|
|
var theirs = Drift(lab, 40, 50);
|
|
a.TractorCommand = 1;
|
|
b.TractorCommand = 1;
|
|
Tick(lab, 30, 1 / 60f);
|
|
Assert.True(ReferenceEquals(a, mine.Holder), "mine is not held by a");
|
|
Assert.True(ReferenceEquals(b, theirs.Holder), "theirs is not held by b");
|
|
|
|
Kill(a);
|
|
Assert.True(mine.Holder == null, "mine is held");
|
|
Assert.True(ReferenceEquals(b, theirs.Holder), "theirs was freed with a");
|
|
}
|
|
|
|
[Fact]
|
|
public void TheHoldersLeavingFreesItsItems()
|
|
{
|
|
using var bag = new CompositeDisposable();
|
|
var lab = Build(Beam());
|
|
var ship = Spawn(lab, float3(0, 0, 0));
|
|
Assert.True(ship.CargoBays.Single().TryStore(lab.Ore(7)));
|
|
var item = Drift(lab, 40, 0, ore: 3);
|
|
ship.TractorCommand = 1;
|
|
Tick(lab, 30, 1 / 60f);
|
|
Assert.True(ReferenceEquals(ship, item.Holder), "item is not held by ship");
|
|
var before = lab.Zone.FloatingItems.Count;
|
|
|
|
// Death goes through the zone's one removal: the held item is free, and the ship's own cargo drops as always.
|
|
Kill(ship);
|
|
Assert.True(item.Holder == null, "item is held");
|
|
Assert.True(lab.Zone.FloatingItems.Contains(item), "item left the zone");
|
|
Assert.Equal(before + 1, lab.Zone.FloatingItems.Count);
|
|
Assert.Equal(7, ((SimpleCommodity) lab.Zone.FloatingItems.Last().Item).Quantity);
|
|
Tick(lab, 60, 1 / 60f);
|
|
Assert.True(lab.Zone.FloatingItems.Contains(item), "item left the zone");
|
|
Assert.True(item.Holder == null, "item is held");
|
|
}
|
|
}
|