362 lines
16 KiB
C#
362 lines
16 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.Linq;
|
|
using CultMath;
|
|
using UniRx;
|
|
using Xunit;
|
|
using static CultMath.math;
|
|
using float2 = CultMath.float2;
|
|
using float3 = CultMath.float3;
|
|
|
|
// Flight control allocates thrust (ruling flight-control-allocates-thrust): Ship.Update hands the intent and every
|
|
// thruster's live column to one ThrustAllocator, and a ship flies on what that answers. These tests fly the Duel's
|
|
// Longinus (two mismatched Large Drives forward, a Rugged Drive on each flank) through the real Ship.Update; a test that reads
|
|
// velocity steps the arena, because the zone places the orbits that Ship.Update alone leaves stacked at the spawn.
|
|
public sealed partial class RunStartTests
|
|
{
|
|
private const float AllocDt = 1f / 60f;
|
|
|
|
private (Zone arena, Ship player) AllocDuel()
|
|
{
|
|
var launched = Launch(new Duel());
|
|
Assert.Empty(launched.failures);
|
|
return (launched.arena, launched.staged.Player);
|
|
}
|
|
|
|
private static Thruster[] AllocDrives(Ship ship) =>
|
|
ship.GetBehaviors<Thruster>().Where(t => t.Item.EquippableItem.Rotation == ItemRotation.Reversed).OrderBy(t => t.NominalThrust).ToArray();
|
|
|
|
// The signed heading change in degrees, positive clockwise, of `ticks` of the ship's own Update.
|
|
private static float AllocFly(Ship ship, int ticks)
|
|
{
|
|
var before = ship.Direction;
|
|
for (var tick = 0; tick < ticks; tick++) ship.Update(AllocDt);
|
|
return degrees(SignedTurn(before, ship.Direction));
|
|
}
|
|
|
|
// The two Large Drives, refitted with lots staged at the low and high end of the makers' assembly range (.55 and .85, each
|
|
// with its parts at its assembly), so their effective qualities differ by construction. The lots are fitted through the
|
|
// ship's own unequip and equip (an active entity refuses both, so it is deactivated for the refit and reactivated), so
|
|
// heat, thrust and the allocator stay the production path.
|
|
private void StageDriveLots(Ship ship)
|
|
{
|
|
ship.Deactivate();
|
|
var drives = AllocDrives(ship).OrderBy(d => d.Item.Position.x).ToArray();
|
|
Assert.Equal(2, drives.Length);
|
|
var assemblies = new[] { .55f, .85f };
|
|
for (var i = 0; i < drives.Length; i++)
|
|
{
|
|
var fitted = drives[i].Item;
|
|
var unit = fitted.EquippableItem;
|
|
var lot = _items.GetLot(unit);
|
|
Assert.NotNull(ship.TryUnequip(fitted));
|
|
var staged = new EquippableItem
|
|
{
|
|
Data = unit.Data, Durability = unit.Durability, Rotation = unit.Rotation,
|
|
Lot = _items.Lots.Add(new Lot
|
|
{
|
|
Design = lot.Design, Origin = lot.Origin, Product = lot.Product, Quality = assemblies[i],
|
|
Roles = (lot.Roles ?? new List<RoleFill>()).Select(r => new RoleFill { Role = r.Role, Quality = assemblies[i] }).ToList()
|
|
})
|
|
};
|
|
Assert.True(ship.TryEquip(staged, fitted.Position));
|
|
}
|
|
ship.Activate();
|
|
}
|
|
|
|
[Fact]
|
|
public void MismatchedDrivesHoldHeading()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
StageDriveLots(player);
|
|
var drives = AllocDrives(player);
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
var heading = AllocFly(player, 120);
|
|
// The drives start alike and heat apart as they fire: by now they are mismatched and both pushing.
|
|
Assert.True(drives.Length >= 2 && drives[^1].NominalThrust > drives[0].NominalThrust * 1.05f, "premise: the drives' NominalThrust spread reaches 5 percent");
|
|
Assert.All(drives, d => Assert.True(d.Axis > .5f, "premise: the drives are pushing"));
|
|
Assert.True(abs(heading) < .1f);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("strongest disabled")]
|
|
[InlineData("weakest disabled")]
|
|
[InlineData("one destroyed")]
|
|
public void ALostDriveStillHoldsHeading(string loss)
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var drives = AllocDrives(player);
|
|
var lost = loss == "weakest disabled" ? drives[0] : drives[^1];
|
|
var kept = loss == "weakest disabled" ? drives[^1] : drives[0];
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
for (var tick = 0; tick < 10; tick++) player.Update(AllocDt);
|
|
if (loss == "one destroyed")
|
|
{
|
|
var destroyed = 0;
|
|
using var sub = player.ItemDestroyed.Subscribe(_ => destroyed++);
|
|
player.ItemAbsorb(lost.Item, new[] { 1e6f });
|
|
Assert.Equal(1, destroyed); // the death event fired
|
|
}
|
|
else lost.Item.Enabled.Value = false;
|
|
player.Update(AllocDt);
|
|
Assert.False(lost.Item.Active.Value);
|
|
|
|
Assert.True(abs(AllocFly(player, 120)) < .1f);
|
|
Assert.True(kept.Axis > .5f, "the live drive pushes");
|
|
Assert.Equal(0f, lost.Axis);
|
|
}
|
|
|
|
[Fact]
|
|
public void ADegradedDriveIsBalancedLive()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var drives = AllocDrives(player);
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
Assert.True(abs(AllocFly(player, 30)) < .1f);
|
|
|
|
// The drive is heated a little off its plateau: its live thrust moves, and a column cached before would not.
|
|
var weakened = drives[^1];
|
|
var before = weakened.Thrust;
|
|
for (var step = 0; step < 20 && weakened.Thrust > before * .9f; step++)
|
|
{
|
|
foreach (var cell in weakened.Item.InsetShape.Coordinates) player.Temperature[cell.x, cell.y] += 2f;
|
|
weakened.Item.UpdatePerformance();
|
|
}
|
|
Assert.True(weakened.Thrust < before * .95f && weakened.Item.Active.Value, "fixture: the heated drive pushes measurably less");
|
|
Assert.True(abs(AllocFly(player, 60)) < .1f);
|
|
}
|
|
|
|
[Fact]
|
|
public void ATinyImbalanceStillHolds()
|
|
{
|
|
using var cache = RestoredHullsTests.OpenCatalog();
|
|
RestoredHullsTests.FreeThrusterPower(cache);
|
|
var ship = RestoredHullsTests.BuildThrustedShip(cache, "Longinus");
|
|
var drives = AllocDrives(ship);
|
|
Assert.True(drives.Length >= 2);
|
|
var other = drives[0];
|
|
var detuned = drives[1];
|
|
|
|
// Detune one drive until its live thrust is .4% under the other's, by bisecting its durability.
|
|
var full = detuned.Item.Data.Durability;
|
|
float lo = 0, hi = 1;
|
|
for (var step = 0; step < 50; step++)
|
|
{
|
|
var mid = (lo + hi) / 2;
|
|
detuned.Item.EquippableItem.Durability = full * mid;
|
|
detuned.Item.UpdatePerformance();
|
|
if (detuned.Thrust < other.Thrust * .996f) lo = mid; else hi = mid;
|
|
}
|
|
var ratio = detuned.Thrust / other.Thrust;
|
|
Assert.InRange(ratio, .995f, .998f);
|
|
|
|
ship.MovementDirection = float2(0, 1);
|
|
ship.Turn = 0;
|
|
// Six seconds: the ship has no heatsinks, and its drives overheat and shut down at about seven.
|
|
Assert.True(abs(AllocFly(ship, 360)) < .05f);
|
|
}
|
|
|
|
// Finding liveness-read-before-performance. Mutation: allocate in Ship.Update before base.Update (the first wiring), so
|
|
// liveness and thrust are read before the performance update that shuts a drive down. A drive heated gradually
|
|
// until it shuts off is balanced out on the tick it dies, not the tick after: the heading steps no more than the
|
|
// disabled path's (0.0002 deg at Enabled = false), the dying drive carries no throttle that tick, and the heading
|
|
// held through the heat-up.
|
|
[Fact]
|
|
public void AThermalShutdownHoldsHeadingOnItsDeathTick()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
for (var tick = 0; tick < 30; tick++) player.Update(AllocDt);
|
|
var dying = AllocDrives(player)[^1];
|
|
var start = player.Direction;
|
|
var shutdown = -1;
|
|
var deathStep = 0f;
|
|
var axisOnDeathTick = -1f;
|
|
for (var tick = 1; tick <= 600 && shutdown < 0; tick++)
|
|
{
|
|
foreach (var cell in dying.Item.InsetShape.Coordinates) player.Temperature[cell.x, cell.y] += 4f;
|
|
var before = player.Direction;
|
|
var wasActive = dying.Item.Active.Value;
|
|
player.Update(AllocDt);
|
|
if (!wasActive || dying.Item.Active.Value) continue;
|
|
shutdown = tick;
|
|
deathStep = degrees(SignedTurn(before, player.Direction));
|
|
axisOnDeathTick = dying.Axis;
|
|
}
|
|
Assert.True(shutdown > 0, "fixture: the heated drive shut down");
|
|
Assert.Equal(0f, axisOnDeathTick);
|
|
Assert.True(abs(deathStep) < .005f, $"the death tick stepped the heading {deathStep} deg");
|
|
Assert.True(abs(degrees(SignedTurn(start, player.Direction))) < .05f, "the heading held through the heat-up");
|
|
Assert.True(abs(AllocFly(player, 60)) < .1f);
|
|
}
|
|
|
|
[Fact]
|
|
public void ARepairedDriveRejoins()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var drive = AllocDrives(player)[^1];
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
drive.Item.Enabled.Value = false;
|
|
for (var tick = 0; tick < 30; tick++) player.Update(AllocDt);
|
|
Assert.Equal(0f, drive.Axis);
|
|
drive.Item.Enabled.Value = true;
|
|
player.Update(AllocDt);
|
|
Assert.True(drive.Axis > .5f);
|
|
}
|
|
|
|
[Fact]
|
|
public void ADeadThrusterNeverGetsThrottle()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var thrusters = player.GetBehaviors<Thruster>().ToArray();
|
|
Assert.True(thrusters.Length >= 4);
|
|
var asks = new (float2 move, float turn)[]
|
|
{
|
|
(float2(0, 1), 0), (float2(0, -1), 0), (float2(1, 0), 0), (float2(-1, 0), 0), (float2(.7f, .7f), 0),
|
|
(float2(0, 0), 1), (float2(0, 0), -1)
|
|
};
|
|
foreach (var dead in thrusters)
|
|
{
|
|
dead.Item.Enabled.Value = false;
|
|
foreach (var (move, turn) in asks)
|
|
{
|
|
player.MovementDirection = move;
|
|
player.Turn = turn;
|
|
for (var tick = 0; tick < 30; tick++)
|
|
{
|
|
player.Update(AllocDt);
|
|
Assert.Equal(0f, dead.Axis);
|
|
}
|
|
}
|
|
dead.Item.Enabled.Value = true;
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void AFullTurnSpendsTheHullsWholeTurn()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var thrusters = player.GetBehaviors<Thruster>().ToArray();
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 1;
|
|
var sum = 0f;
|
|
var extremeSum = 0f;
|
|
var count = 0;
|
|
for (var tick = 0; tick < 60; tick++)
|
|
{
|
|
// The clockwise box extreme this tick: every thruster that turns clockwise, at full, from its own column.
|
|
var extreme = thrusters.Sum(t => max(t.Column(t.NominalThrust).z, 0f));
|
|
player.Update(AllocDt);
|
|
if (tick < 10) continue;
|
|
sum += player.TurnRate;
|
|
extremeSum += extreme;
|
|
count++;
|
|
}
|
|
Assert.True(extremeSum > 0f);
|
|
Assert.True(sum >= .98f * extremeSum, $"the turn spent {sum / extremeSum} of the hull's whole");
|
|
}
|
|
|
|
[Fact]
|
|
public void TheDuelFliesStraightWhenTheArenaIsStepped()
|
|
{
|
|
var (arena, player) = AllocDuel();
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
var start = player.Direction;
|
|
var previous = 0f;
|
|
for (var tick = 0; tick < 240; tick++)
|
|
{
|
|
arena.Update(AllocDt);
|
|
var along = dot(player.Velocity, normalize(player.Direction));
|
|
var oneTickOfDrag = previous - decay(previous, player.HullData.Drag, AllocDt);
|
|
Assert.True(along >= previous - oneTickOfDrag - 1e-3f, $"tick {tick}: along-nose speed fell from {previous} to {along}");
|
|
previous = along;
|
|
}
|
|
Assert.True(previous > 10f, "fixture: the ship got going");
|
|
Assert.True(abs(degrees(SignedTurn(start, player.Direction))) < .1f);
|
|
}
|
|
|
|
// The allocator runs while the ship flies and not while a wormhole animation scripts it: the throttles a ship
|
|
// carries into the animation are the ones it keeps, whatever the pilot asks meanwhile.
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void TheThrottlesFreezeForAWormholeAnimation(bool entering)
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
var thrusters = player.GetBehaviors<Thruster>().ToArray();
|
|
player.MovementDirection = float2(0, 1);
|
|
player.Turn = 0;
|
|
for (var tick = 0; tick < 30; tick++) player.Update(AllocDt);
|
|
var flying = thrusters.Select(t => t.Axis).ToArray();
|
|
Assert.True(flying.Max() > .5f, "fixture: the allocator drives the thrusters while the ship flies");
|
|
|
|
if (entering) player.EnterWormhole(player.Position.xz + float2(50, 0));
|
|
else player.ExitWormhole(player.Position.xz + float2(50, 0), float2(0, 20));
|
|
player.MovementDirection = float2(0, 0);
|
|
player.Turn = 1;
|
|
for (var tick = 0; tick < 5; tick++)
|
|
{
|
|
player.Update(AllocDt);
|
|
Assert.True(player.WormholeAnimationInProgress, "fixture: the animation is still running");
|
|
Assert.Equal(flying, thrusters.Select(t => t.Axis).ToArray());
|
|
}
|
|
}
|
|
|
|
// Capability is one model (ruling turn-authority-full): the envelope's turn is what a full command achieves. The
|
|
// Duel's Longinus turns in place under Turn +1 then -1, stepped with its own Update (heading only), and the mean turn
|
|
// rate over ticks 10-60 is the envelope's clockwise and counter-clockwise.
|
|
[Fact]
|
|
public void TheEnvelopeIsWhatAFullCommandAchieves()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
player.MovementDirection = float2(0, 0);
|
|
foreach (var (turn, side) in new[] { (1f, "clockwise"), (-1f, "counter-clockwise") })
|
|
{
|
|
player.Turn = turn;
|
|
var sum = 0f;
|
|
var envelopeSum = 0f;
|
|
for (var tick = 0; tick < 60; tick++)
|
|
{
|
|
player.Update(AllocDt);
|
|
if (tick < 10) continue;
|
|
sum += abs(player.TurnRate);
|
|
envelopeSum += turn > 0 ? player.Envelope.Clockwise : player.Envelope.CounterClockwise;
|
|
}
|
|
Assert.True(envelopeSum > 0f, $"fixture: the {side} envelope is not empty");
|
|
Assert.InRange(sum, envelopeSum * .99f, envelopeSum * 1.01f);
|
|
}
|
|
}
|
|
|
|
// Rulings evasion-is-unpredictability and turn-authority-full: the Longinus's Large Drives count toward its turn,
|
|
// because the envelope is summed over every live column. Its clockwise is the sum of the positive yaw of its columns
|
|
// at live thrust, and exceeds the Rugged Drive's own by the drives'.
|
|
[Fact]
|
|
public void TheEnvelopeCountsTheMains()
|
|
{
|
|
var (_, player) = AllocDuel();
|
|
player.MovementDirection = float2(0, 0);
|
|
player.Turn = 0;
|
|
for (var tick = 0; tick < 10; tick++) player.Update(AllocDt);
|
|
var thrusters = player.GetBehaviors<Thruster>().Where(t => t.Item.Active.Value).ToArray();
|
|
var drives = thrusters.Where(t => t.Item.Data.Name == "Large Drive").ToArray();
|
|
var flanks = thrusters.Where(t => t.Item.Data.Name == "Rugged Drive").ToArray();
|
|
Assert.Equal(2, drives.Length);
|
|
Assert.Equal(2, flanks.Length);
|
|
float Clockwise(IEnumerable<Thruster> of) => of.Sum(t => max(t.Column(t.Thrust).z, 0f));
|
|
var expected = Clockwise(thrusters);
|
|
Assert.InRange(player.Envelope.Clockwise, expected * (1 - 1e-4f), expected * (1 + 1e-4f));
|
|
Assert.True(Clockwise(drives) > .1f, "fixture: the Large Drives turn the Longinus");
|
|
Assert.True(player.Envelope.Clockwise > Clockwise(flanks) + .9f * Clockwise(drives),
|
|
"the mains' turn is in the envelope, over the flank thrusters' own");
|
|
}
|
|
}
|