diff --git a/Assets/Scripts/ServerShared/Behaviors/Behaviors.cs b/Assets/Scripts/ServerShared/Behaviors/Behaviors.cs index 9f2e292a6..4b07d7bb8 100644 --- a/Assets/Scripts/ServerShared/Behaviors/Behaviors.cs +++ b/Assets/Scripts/ServerShared/Behaviors/Behaviors.cs @@ -187,6 +187,7 @@ public interface IPowerConsumer // superseded draft quoted -- checked directly here rather than trusted from that document. Union(39, typeof(TargetingSystemData)), Union(40, typeof(MineLayerData)), +Union(41, typeof(ThrottleLockData)), JsonObject(MemberSerialization.OptIn)] public abstract class BehaviorData { diff --git a/Assets/Scripts/ServerShared/Behaviors/ThrottleLock.cs b/Assets/Scripts/ServerShared/Behaviors/ThrottleLock.cs new file mode 100644 index 000000000..d33ef07cb --- /dev/null +++ b/Assets/Scripts/ServerShared/Behaviors/ThrottleLock.cs @@ -0,0 +1,35 @@ +/* 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 MessagePack; +using Newtonsoft.Json; + +// Presence marks the lock: Entity.ThrottleLocked is true while an active effect carries one, and Ship.Update +// then reads full forward intent in place of MovementDirection. The behaviour holds no state and does nothing +// itself; turning stays with the pilot. +[Inspectable, MessagePackObject, JsonObject(MemberSerialization.OptIn), RuntimeInspectable] +public class ThrottleLockData : BehaviorData +{ + public override Behavior CreateInstance(EquippedItem item) + { + return new ThrottleLock(this, item); + } + public override Behavior CreateInstance(ConsumableItemEffect item) + { + return new ThrottleLock(this, item); + } +} + +public class ThrottleLock : Behavior +{ + public ThrottleLock(ThrottleLockData data, EquippedItem item) : base(data, item) + { + } + + public ThrottleLock(ThrottleLockData data, ConsumableItemEffect item) : base(data, item) + { + } + + public override bool Execute(float dt) => true; +} diff --git a/Assets/Scripts/ServerShared/Entity.cs b/Assets/Scripts/ServerShared/Entity.cs index 1da6e68d8..4855db616 100644 --- a/Assets/Scripts/ServerShared/Entity.cs +++ b/Assets/Scripts/ServerShared/Entity.cs @@ -863,6 +863,9 @@ public abstract class Entity _activeConsumables.Add(new ConsumableItemEffect(item, this)); } + // Derived, never written: true iff an active consumable effect carries a ThrottleLock. + public bool ThrottleLocked => _activeConsumables.Any(e => e.Behaviors.OfType().Any()); + public ConsumableItemEffect FindActiveConsumable(ConsumableItemData data) { return _activeConsumables.FirstOrDefault(ac => ac.Data == data); diff --git a/Assets/Scripts/ServerShared/Ship.cs b/Assets/Scripts/ServerShared/Ship.cs index 98dfa4fb3..993d92940 100644 --- a/Assets/Scripts/ServerShared/Ship.cs +++ b/Assets/Scripts/ServerShared/Ship.cs @@ -233,27 +233,29 @@ public class Ship : Entity if (_active && !_exitingWormhole && !_enteringWormhole) { RecalculateThrust(); + // The lock replaces intent here, once; player and agent intent both pass through this one read. + var move = ThrottleLocked ? float2(0, 1) : MovementDirection; foreach (var thruster in _allThrusters) thruster.Axis = 0; var rightThrusterTorqueCompensation = abs(RightStrafeTotalTorque) / RightStrafeTorqueThrusters.Count; foreach (var thruster in _rightThrusters) { var thrust = 0f; - thrust += MovementDirection.x; + thrust += move.x; if (RightStrafeTorqueThrusters.Contains(thruster)) - thrust -= MovementDirection.x * (rightThrusterTorqueCompensation / (abs(thruster.Torque) * thruster.Thrust)); + thrust -= move.x * (rightThrusterTorqueCompensation / (abs(thruster.Torque) * thruster.Thrust)); thruster.Axis = thrust; } var leftThrusterTorqueCompensation = abs(LeftStrafeTotalTorque) / LeftStrafeTorqueThrusters.Count; foreach (var thruster in _leftThrusters) { var thrust = 0f; - thrust += -MovementDirection.x; + thrust += -move.x; if (LeftStrafeTorqueThrusters.Contains(thruster)) - thrust += MovementDirection.x * (leftThrusterTorqueCompensation / (abs(thruster.Torque) * thruster.Thrust)); + thrust += move.x * (leftThrusterTorqueCompensation / (abs(thruster.Torque) * thruster.Thrust)); thruster.Axis = thrust; } - foreach (var thruster in _forwardThrusters) thruster.Axis += MovementDirection.y; - foreach (var thruster in _reverseThrusters) thruster.Axis += -MovementDirection.y; + foreach (var thruster in _forwardThrusters) thruster.Axis += move.y; + foreach (var thruster in _reverseThrusters) thruster.Axis += -move.y; foreach (var thruster in _clockwiseThrusters) thruster.Axis += Turn; foreach (var thruster in _counterClockwiseThrusters) thruster.Axis += -Turn; diff --git a/tests/Aetheria.Shared.Tests/ThrottleLockTests.cs b/tests/Aetheria.Shared.Tests/ThrottleLockTests.cs new file mode 100644 index 000000000..1673e2be1 --- /dev/null +++ b/tests/Aetheria.Shared.Tests/ThrottleLockTests.cs @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using CultMath; +using GameCult.Caching; +using Xunit; +using static CultMath.math; + +// A ThrottleLock on an active consumable replaces the pilot's movement intent with full forward, read once at +// the top of Ship.Update's active branch. Turn is untouched. Every observation is a thruster's Axis after a real +// Ship.Update, with the effect started through Entity.ActivateConsumable. +public sealed class ThrottleLockTests : IDisposable +{ + private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-throttlelock-" + Guid.NewGuid().ToString("N")); + private string Catalog => Path.Combine(_root, "Aetheria.cc"); + + public ThrottleLockTests() => Directory.CreateDirectory(_root); + public void Dispose() => Directory.Delete(_root, true); + + private static GameplaySettings 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() + }; + + private static PerformanceStat Constant(float v) => new PerformanceStat { Min = v, Max = v }; + + private static EquippableItem Mint(CultCache cache, ItemManager items, ItemData design, ItemRotation rotation = ItemRotation.None) => new EquippableItem + { + Data = cache.RefOf(design), + Durability = design is EquippableItemData equippable ? equippable.Durability : 0, + Rotation = rotation, + Lot = items.Lots.Add(new Lot { Design = cache.RefOf(design), Origin = new Attributed(), Quality = .5f, Roles = new List() }) + }; + + private sealed class Fixture + { + public CultCache Cache; + public ItemManager Items; + public Ship Ship; + public ConsumableItemData Lock; + public Thruster Forward, Reverse, Right, Left, Clockwise; + + public void ActivateLock() => Ship.ActivateConsumable(new ConsumableItem + { + Data = Cache.RefOf(Lock), + Lot = Items.Lots.Add(new Lot { Design = Cache.RefOf(Lock), Origin = new Attributed(), Quality = .5f, Roles = new List() }) + }); + } + + // One thruster per intent direction, plus two reverse thrusters either side of the centre line, one of + // which has clockwise torque (the one Turn reaches). Thrusters are found by their item's rotation, as Ship + // sorts them. + private Fixture Build(float lockDuration) + { + var cache = AetheriaStores.Open(Catalog, catalogWritable: true); + cache.Upsert(new TestCatalogGlobal { Name = "Temperament" }); + var hullShape = new Shape(5, 5); + foreach (var cell in hullShape.AllCoordinates) hullShape[cell] = true; + cache.Upsert(new HullData { Name = "Skiff", HullType = HullType.Ship, Shape = hullShape, Durability = 10, Mass = 1000 }); + cache.Upsert(new GearData + { + Name = "Thruster", Hardpoint = HardpointType.Tool, Shape = new Shape(), Durability = 10, + MinimumTemperature = 0, MaximumTemperature = 1000, OptimalTemperature = 280, PlateauWidth = 400, + Behaviors = { new ThrusterData { Thrust = Constant(100), Visibility = Constant(0), Heat = Constant(0), EnergyUsage = Constant(0) } } + }); + var lockData = new ConsumableItemData { Name = "Overdrive", Duration = lockDuration, Behaviors = { new ThrottleLockData() } }; + cache.Upsert(lockData); + cache.FlushAsync().Wait(); + + var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { }); + var zone = new Zone(items, new PlanetSettings(), new ZonePack(), new GalaxyZone { Name = "Test Zone", Owner = null }, null); + var ship = new Ship(items, zone, Mint(cache, items, cache.GetByName("Skiff")), new EntitySettings()); + var gear = cache.GetByName("Thruster"); + Assert.True(ship.TryEquip(Mint(cache, items, gear, ItemRotation.Reversed), new int2(2, 1))); + Assert.True(ship.TryEquip(Mint(cache, items, gear, ItemRotation.None), new int2(0, 2))); + Assert.True(ship.TryEquip(Mint(cache, items, gear, ItemRotation.None), new int2(4, 2))); + Assert.True(ship.TryEquip(Mint(cache, items, gear, ItemRotation.CounterClockwise), new int2(3, 3))); + Assert.True(ship.TryEquip(Mint(cache, items, gear, ItemRotation.Clockwise), new int2(1, 3))); + zone.Entities.Add(ship); + ship.Aim = float3(0, 0, 1); + ship.Activate(); + + var thrusters = ship.GetBehaviors().ToArray(); + return new Fixture + { + Cache = cache, Items = items, Ship = ship, Lock = cache.GetByName("Overdrive"), + Forward = thrusters.Single(t => t.Item.EquippableItem.Rotation == ItemRotation.Reversed), + Right = thrusters.Single(t => t.Item.EquippableItem.Rotation == ItemRotation.CounterClockwise), + Left = thrusters.Single(t => t.Item.EquippableItem.Rotation == ItemRotation.Clockwise), + Reverse = thrusters.First(t => t.Item.EquippableItem.Rotation == ItemRotation.None && t.Torque <= 0), + Clockwise = thrusters.First(t => t.Item.EquippableItem.Rotation == ItemRotation.None && t.Torque > 0) + }; + } + + // Spec ALockedThrottleIgnoresIntent. Mutation: read MovementDirection in place of move at any of the six + // sites in Ship.Update and the matching assertion goes red. + [Fact] + public void ALockedThrottleIgnoresIntent() + { + var f = Build(100f); + using var _ = f.Cache; + f.ActivateLock(); + Assert.True(f.Ship.ThrottleLocked); + + foreach (var intent in new[] { float2(0, -1), float2(1, 0), float2(-1, 0) }) + { + f.Ship.MovementDirection = intent; + f.Ship.Turn = 0; + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Forward.Axis); + Assert.Equal(0f, f.Reverse.Axis); + Assert.Equal(0f, f.Right.Axis); + Assert.Equal(0f, f.Left.Axis); + } + + // Turning stays with the pilot: the clockwise-torque thruster follows Turn while the lock holds. + f.Ship.MovementDirection = float2(0, -1); + f.Ship.Turn = 1; + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Clockwise.Axis); + f.Ship.Turn = 0; + f.Ship.Update(0.01f); + Assert.Equal(0f, f.Clockwise.Axis); + } + + // Spec TheLockEndsWithItsEffect. Mutation: make ThrottleLocked a latch (set on activation, never cleared) + // and the post-expiry reverse axis stays 0. + [Fact] + public void TheLockEndsWithItsEffect() + { + var f = Build(1f); + using var _ = f.Cache; + f.ActivateLock(); + f.Ship.MovementDirection = float2(0, -1); + f.Ship.Update(0.5f); + Assert.Equal(0f, f.Reverse.Axis); + + f.Ship.Update(2f); // runs past the Duration; the effect leaves at the end of this tick + Assert.False(f.Ship.ThrottleLocked); + + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Reverse.Axis); + Assert.Equal(0f, f.Forward.Axis); + } + + // Spec AnUnlockedShipFollowsIntent. Mutation: replace the conditional by an unconditional float2(0, 1) and + // the reverse and strafe assertions go red. + [Fact] + public void AnUnlockedShipFollowsIntent() + { + var f = Build(1f); + using var _ = f.Cache; + Assert.False(f.Ship.ThrottleLocked); + + f.Ship.MovementDirection = float2(0, -1); + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Reverse.Axis); + Assert.Equal(0f, f.Forward.Axis); + + f.Ship.MovementDirection = float2(1, 0); + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Right.Axis); + Assert.Equal(0f, f.Left.Axis); + Assert.Equal(0f, f.Forward.Axis); + + f.Ship.MovementDirection = float2(0, 1); + f.Ship.Update(0.01f); + Assert.Equal(1f, f.Forward.Axis); + Assert.Equal(0f, f.Reverse.Axis); + } +}