From b1f4a2aa08449588057342134b6e349e4e1b5c40 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 12 Oct 2026 03:38:29 +0200 Subject: [PATCH] Vectored rows recorded: HardpointData.Row, ThrusterData.Slew, the judge's row rules Thruster hardpoints state a gimbal arc in FiringArc and join a row by Row (key 7); the thruster design carries its slew (key 6). The judge refuses a Row on a non-thruster, rows whose members disagree on Rotation or FiringArc, and a fixed thruster, a mixed or split row, or a joint too short for the arc on a joint. Bind treats a thruster emitter's joint as it treats a gun mount's. Not yet verified: this commit has not been built. Co-Authored-By: Claude Opus 5.5 --- .../ServerShared/Behaviors/Thruster.cs | 5 + Assets/Scripts/ServerShared/ItemData.cs | 5 + Assets/Scripts/ServerShared/ShipAuthoring.cs | 46 +++- Assets/Scripts/ServerShared/ShipModCatalog.cs | 10 +- tests/Aetheria.Shared.Tests/ShipRigTests.cs | 211 +++++++++++++++++- .../ShipValidationTests.cs | 21 +- 6 files changed, 284 insertions(+), 14 deletions(-) diff --git a/Assets/Scripts/ServerShared/Behaviors/Thruster.cs b/Assets/Scripts/ServerShared/Behaviors/Thruster.cs index 4a36d9528..b15378cea 100644 --- a/Assets/Scripts/ServerShared/Behaviors/Thruster.cs +++ b/Assets/Scripts/ServerShared/Behaviors/Thruster.cs @@ -25,6 +25,11 @@ public class ThrusterData : BehaviorData [Inspectable, CultInspectorAssetGuid, JsonProperty("Particles"), Key(5)] public string ParticlesPrefab; + + // The gimbal's slew rate in degrees per second: the part's own stat, as a weapon's traverse is + // (ruling mount-arc-gun-traverse). The swing limit is the hardpoint's FiringArc, the row its Row. + [Inspectable, JsonProperty("slew"), Key(6), RuntimeInspectable] + public PerformanceStat Slew = new PerformanceStat(); public override Behavior CreateInstance(EquippedItem item) { diff --git a/Assets/Scripts/ServerShared/ItemData.cs b/Assets/Scripts/ServerShared/ItemData.cs index ef1b3f46f..302a02085 100644 --- a/Assets/Scripts/ServerShared/ItemData.cs +++ b/Assets/Scripts/ServerShared/ItemData.cs @@ -566,7 +566,12 @@ public class HardpointData [Inspectable, JsonProperty("armor"), Key(5)] public float Armor; // Full arc width in degrees a weapon on this hardpoint may bear across; 0 means "use // GameplaySettings.FiringArc" (docs/fire-control-cut.md R6). Turrets author 360 (Q1). + // On a Thruster hardpoint it is the full gimbal width: the row swings +-FiringArc/2 about Rotation, 0 is a + // fixed thruster, and there is no GameplaySettings fallback. [Inspectable, JsonProperty("firingArc"), Key(6)] public float FiringArc; + // Thruster hardpoints sharing a non-empty Row swing as one row; a Thruster hardpoint with FiringArc > 0 and no Row + // is a row of one. Only a Thruster hardpoint may state one. + [Inspectable, JsonProperty("row"), Key(7)] public string Row; public override string ToString() { diff --git a/Assets/Scripts/ServerShared/ShipAuthoring.cs b/Assets/Scripts/ServerShared/ShipAuthoring.cs index 7120d7429..b86eab8ae 100644 --- a/Assets/Scripts/ServerShared/ShipAuthoring.cs +++ b/Assets/Scripts/ServerShared/ShipAuthoring.cs @@ -262,6 +262,8 @@ public static class ShipAuthoringStore throw new InvalidOperationException($"{ship.Id}: hardpoint {hardpoint.Transform} has an unknown rotation {(int)hardpoint.Rotation}."); if (!float.IsFinite(hardpoint.Armor) || hardpoint.Armor < 0 || !float.IsFinite(hardpoint.FiringArc) || hardpoint.FiringArc < 0) throw new InvalidOperationException($"{ship.Id}: hardpoint {hardpoint.Transform} armor and firing arc must be finite and not negative."); + if (!string.IsNullOrEmpty(hardpoint.Row) && hardpoint.Type != HardpointType.Thruster) + throw new InvalidOperationException($"{ship.Id}: hardpoint {hardpoint.Transform} is a {hardpoint.Type} hardpoint, and only a Thruster hardpoint may state a row."); if (hardpoint.Shape?.Cells == null || !hardpoint.Shape.Cells.Cast().Any(occupied => occupied)) throw new InvalidOperationException($"{ship.Id}: hardpoint {hardpoint.Transform} has no cells."); for (var cellX = 0; cellX < hardpoint.Shape.Width; cellX++) @@ -285,6 +287,16 @@ public static class ShipAuthoringStore if (mountRole != null && mountAnchor.Role != mountRole) throw new InvalidOperationException($"{ship.Id}: {hardpoint.Type} hardpoint {hardpoint.Transform} needs a {mountRole} anchor of that id."); } + foreach (var row in mounts.Values.Where(hardpoint => hardpoint.Type == HardpointType.Thruster && !string.IsNullOrEmpty(hardpoint.Row)) + .GroupBy(hardpoint => hardpoint.Row, StringComparer.Ordinal)) + { + var lead = row.First(); + foreach (var hardpoint in row) + if (hardpoint.Rotation != lead.Rotation || hardpoint.FiringArc != lead.FiringArc) + throw new InvalidOperationException($"{ship.Id}: thruster hardpoints {lead.Transform} and {hardpoint.Transform} are in row {row.Key} and must share Rotation and FiringArc."); + if (!(lead.FiringArc > 0f) || lead.FiringArc > 360f) + throw new InvalidOperationException($"{ship.Id}: thruster row {row.Key} must state a gimbal FiringArc above 0 and at most 360."); + } foreach (var anchor in anchors) { if (!string.IsNullOrEmpty(anchor.ParentId) && !mounts.ContainsKey(anchor.ParentId)) @@ -371,12 +383,12 @@ public static class ShipAuthoringStore foreach (var anchor in anchors.Where(anchor => !string.IsNullOrEmpty(anchor.Joint))) { - if (anchor.Role == "thruster-emitter" || anchor.Role == "radiator-mesh") - throw new InvalidOperationException($"{ship.Id}: {anchor.Role} anchor {anchor.Id} may not ride a joint (follow-up gimballed-thrusters)."); - if (anchor.Role != "weapon-mount") - throw new InvalidOperationException($"{ship.Id}: {anchor.Role} anchor {anchor.Id} may not name a joint; only a weapon mount rides one."); + if (anchor.Role == "radiator-mesh") + throw new InvalidOperationException($"{ship.Id}: {anchor.Role} anchor {anchor.Id} may not ride a joint."); + if (anchor.Role != "weapon-mount" && anchor.Role != "thruster-emitter") + throw new InvalidOperationException($"{ship.Id}: {anchor.Role} anchor {anchor.Id} may not name a joint; only a weapon mount or a thruster emitter rides one."); if (!byId.ContainsKey(anchor.Joint)) - throw new InvalidOperationException($"{ship.Id}: weapon mount {anchor.Id} names an unknown joint."); + throw new InvalidOperationException($"{ship.Id}: {anchor.Role} anchor {anchor.Id} names an unknown joint."); } var ridden = anchors.Where(anchor => anchor.Role == "weapon-mount" && !string.IsNullOrEmpty(anchor.Joint)) @@ -394,6 +406,30 @@ public static class ShipAuthoringStore if (reach < lead.FiringArc) throw new InvalidOperationException($"{ship.Id}: joint {group.Key} chain reaches {reach} degrees of yaw, short of the {lead.FiringArc} degree firing arc of {lead.Transform}."); } + + // A thruster row is a gimbal: its hardpoints' stated FiringArc is how far the row swings, so a row on a joint rides it + // whole and alone, and the joint's chain must be able to sweep that arc. A hardpoint with no Row is a row of one. + var thrusters = mounts.Values.Where(hardpoint => hardpoint.Type == HardpointType.Thruster).ToArray(); + string RowOf(HardpointData hardpoint) => string.IsNullOrEmpty(hardpoint.Row) ? null : hardpoint.Row; + var jointOf = anchors.Where(anchor => anchor.Role == "thruster-emitter").ToDictionary(anchor => anchor.Id, anchor => anchor.Joint ?? "", StringComparer.Ordinal); + var tilted = thrusters.Where(hardpoint => jointOf.TryGetValue(hardpoint.Transform, out var joint) && joint.Length > 0).ToArray(); + foreach (var hardpoint in tilted) + if (!(hardpoint.FiringArc > 0f)) + throw new InvalidOperationException($"{ship.Id}: thruster hardpoint {hardpoint.Transform} rides a joint, so it must state its firing arc above 0; a fixed thruster may not ride a joint."); + foreach (var onJoint in tilted.GroupBy(hardpoint => jointOf[hardpoint.Transform], StringComparer.Ordinal)) + { + var lead = onJoint.First(); + foreach (var hardpoint in onJoint) + if (RowOf(hardpoint) != RowOf(lead) || RowOf(hardpoint) == null && hardpoint != lead) + throw new InvalidOperationException($"{ship.Id}: joint {onJoint.Key} carries thruster hardpoints {lead.Transform} and {hardpoint.Transform} of different rows; a joint carries one row."); + var members = RowOf(lead) == null ? new[] { lead } : thrusters.Where(hardpoint => RowOf(hardpoint) == RowOf(lead)).ToArray(); + foreach (var member in members) + if (!jointOf.TryGetValue(member.Transform, out var memberJoint) || memberJoint != onJoint.Key) + throw new InvalidOperationException($"{ship.Id}: thruster hardpoint {member.Transform} is in the row of {lead.Transform} on joint {onJoint.Key} and must ride it too; a row rides one joint whole."); + var reach = YawReach(ship, onJoint.Key); + if (reach < lead.FiringArc) + throw new InvalidOperationException($"{ship.Id}: joint {onJoint.Key} chain reaches {reach} degrees of yaw, short of the {lead.FiringArc} degree gimbal arc of {lead.Transform}."); + } } // The yaw a driven joint's chain can sweep: the summed range of every degree of freedom whose axis is yaw, capped at a turn. diff --git a/Assets/Scripts/ServerShared/ShipModCatalog.cs b/Assets/Scripts/ServerShared/ShipModCatalog.cs index b997add7f..1f7bd2647 100644 --- a/Assets/Scripts/ServerShared/ShipModCatalog.cs +++ b/Assets/Scripts/ServerShared/ShipModCatalog.cs @@ -193,8 +193,8 @@ public static class ShipModCatalog } // The rig the record states must be the rig the model has: every joint is a node, each joint's Parent and each mount's - // Joint is the nearest joint above its node, ancestors without an id being walked through by ReadNodeIds, and a thruster or radiator - // mesh sits under no joint (follow-up gimballed-thrusters). + // Joint is the nearest joint above its node, ancestors without an id being walked through by ReadNodeIds, and a radiator + // mesh sits under no joint. private static void BindRig(ShipAuthoring ship, Dictionary nodes) { var joints = new HashSet((ship.Joints ?? new List()).Select(joint => joint.Id), StringComparer.Ordinal); @@ -220,9 +220,9 @@ public static class ShipModCatalog { var above = JointAbove(anchor.ModelNodeId); if (string.Equals(above ?? "", anchor.Joint ?? "", StringComparison.Ordinal)) continue; - throw new InvalidOperationException(anchor.Role == "weapon-mount" - ? $"{ship.Id}: weapon mount {anchor.Id} must name the nearest joint above its model node as its Joint." - : $"{ship.Id}: {anchor.Role} anchor {anchor.Id} sits under a joint in the model (follow-up gimballed-thrusters)."); + throw new InvalidOperationException(anchor.Role == "radiator-mesh" + ? $"{ship.Id}: {anchor.Role} anchor {anchor.Id} sits under a joint in the model." + : $"{ship.Id}: {(anchor.Role == "weapon-mount" ? "weapon mount" : "thruster emitter")} {anchor.Id} must name the nearest joint above its model node as its Joint."); } } diff --git a/tests/Aetheria.Shared.Tests/ShipRigTests.cs b/tests/Aetheria.Shared.Tests/ShipRigTests.cs index 84195c65d..ada408fc9 100644 --- a/tests/Aetheria.Shared.Tests/ShipRigTests.cs +++ b/tests/Aetheria.Shared.Tests/ShipRigTests.cs @@ -4,6 +4,8 @@ using System.IO; using System.Linq; using System.Text; using CultMath; +using GameCult.Caching.MessagePack; +using MessagePack; using Xunit; // The rig in the visual record: what the judge (Validate) refuses about joints and the guns that ride them, what Bind @@ -295,9 +297,41 @@ public sealed class ShipRigTests : IDisposable BindRefusal(Package(ship => ship.Visual.Joints.Single(joint => joint.Id == "elbow").Parent = null))); } + // The thruster's emission mesh follows the same rule as a gun mount: its record names the nearest joint above its node. [Fact] - public void BindRefusesAThrusterMeshUnderAJointNamingTheFollowUp() => - Assert.Contains("gimballed-thrusters", BindRefusal(Package(null, Reparent("thruster-port", "wrist")))); + public void BindAcceptsAThrusterRowOnTheJointItsMeshHangsUnder() + { + var package = ShipModCatalog.ReadPackage(Package(ship => + { + var thruster = ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Transform == "thruster.port"); + thruster.FiringArc = 90; + ship.Visual.Anchors.Single(anchor => anchor.Id == "thruster.port").Joint = "arm"; + }, Reparent("thruster-port", "arm"))); + Assert.Equal("arm", package.Visual.Anchors.Single(anchor => anchor.Id == "thruster.port").Joint); + } + + [Fact] + public void BindRefusesAThrusterMeshThatTheRecordAndTheModelPlaceDifferently() + { + // The record says the thruster is fixed; the model hangs its mesh under the wrist. + Assert.Contains("thruster emitter thruster.port must name the nearest joint above its model node", + BindRefusal(Package(null, Reparent("thruster-port", "wrist")))); + // The record rides the arm; the model leaves the mesh at the root. + Assert.Contains("thruster emitter thruster.port must name the nearest joint above its model node", + BindRefusal(Package(ship => + { + ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Transform == "thruster.port").FiringArc = 90; + ship.Visual.Anchors.Single(anchor => anchor.Id == "thruster.port").Joint = "arm"; + }))); + } + + [Fact] + public void BindRefusesARadiatorMeshUnderAJoint() => + Assert.Contains("radiator-mesh anchor thruster.port sits under a joint in the model", BindRefusal(Package(ship => + { + ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Transform == "thruster.port").Type = HardpointType.Radiator; + ship.Visual.Anchors.Single(anchor => anchor.Id == "thruster.port").Role = "radiator-mesh"; + }, Reparent("thruster-port", "wrist")))); [Fact] public void NodeParentsAreTheNearestTaggedAncestorAndRootsHaveNone() @@ -381,4 +415,177 @@ public sealed class ShipRigTests : IDisposable [Fact] public void AShipWithNoGunOnAJointHasNoRigs() => Assert.Empty(ShipModPlan.Build(Armed((string)null).Hull, Armed((string)null).Visual).Rigs); + + // ---- Thruster rows: a row's gimbal is the hardpoints' FiringArc, its members share a Row, its joint only draws it ---- + + // The fixture's skiff with thrusters "t0".."tN" side by side (one cell each, the fixture's own thruster dropped). Each + // tuple is a thruster's Row (null for none), its FiringArc, and the joint its emitter rides (null for none). + private static ShipParts Thrusting(params (string Row, float Arc, string Joint)[] thrusters) + { + var ship = ShipAuthoringTests.Fixture(); + var shape = new Shape(thrusters.Length, 1); + for (var x = 0; x < thrusters.Length; x++) shape.Cells[x, 0] = true; + ship.Hull.Shape = shape; + ship.Hull.Hardpoints.Clear(); + ship.Visual.Anchors.RemoveAll(anchor => anchor.Id == "thruster.port"); + for (var index = 0; index < thrusters.Length; index++) + { + ship.Hull.Hardpoints.Add(new HardpointData + { + Type = HardpointType.Thruster, Position = new int2(index, 0), Shape = new Shape(), Transform = $"t{index}", + Row = thrusters[index].Row, FiringArc = thrusters[index].Arc + }); + ship.Visual.Anchors.Add(new ShipAnchor { Id = $"t{index}", Role = "thruster-emitter", ModelNodeId = $"t{index}", Joint = thrusters[index].Joint }); + } + return ship; + } + + private static ShipParts OnJoint(ShipParts ship, string id, params (float[] Axis, float Min, float Max)[] dofs) + { + ship.Visual.Joints.Add(Joint(id, null, dofs)); + return ship; + } + + [Fact] + public void ARowIsOnlyForThrusters() + { + // The same Row that a Thruster hardpoint carries is refused on a weapon hardpoint, naming the hardpoint and its type. + Thrusting(("r", 90f, null)).Validate(); + var ship = Armed((string)null); + ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Transform == "g0").Row = "r"; + var message = Refusal(ship); + Assert.Contains("hardpoint g0 is a Energy hardpoint", message); + Assert.Contains("only a Thruster hardpoint may state a row", message); + } + + [Fact] + public void ARowOfThrustersSharingRotationAndArcIsValidWhateverTheArc() + { + Thrusting(("r", 90f, null), ("r", 90f, null)).Validate(); + Thrusting(("r", 360f, null), ("r", 360f, null)).Validate(); + Thrusting(("r", .5f, null)).Validate(); + // A thruster with no Row and no arc is simply a fixed thruster. + Thrusting((null, 0f, null), (null, 0f, null)).Validate(); + } + + [Fact] + public void AThrusterRowMayRideAJoint() + { + // gimballed-thrusters: two emitters of one row (arc 90) on a joint that sweeps 90 degrees of yaw. + OnJoint(Thrusting(("r", 90f, "j"), ("r", 90f, "j")), "j", (Up, -45f, 45f)).Validate(); + // A thruster with an arc and no Row is a row of one, and rides a joint the same way. + OnJoint(Thrusting((null, 90f, "j")), "j", (Up, -45f, 45f)).Validate(); + // Serial degrees of freedom add, exactly as they do for a gun. + OnJoint(Thrusting(("r", 120f, "j")), "j", (Up, -30f, 30f), (Up, -30f, 30f)).Validate(); + } + + [Fact] + public void AFixedThrusterMayNotRideAJoint() + { + var ship = OnJoint(Thrusting((null, 0f, "j")), "j", (Up, -180f, 180f)); + Assert.Contains("thruster hardpoint t0 rides a joint, so it must state its firing arc above 0", Refusal(ship)); + // Fixed and on no joint, it is fine. + ship.Visual.Anchors.Single(anchor => anchor.Id == "t0").Joint = null; + ship.Validate(); + } + + [Fact] + public void AJointShortOfTheRowsArcIsRefused() + { + var short1 = Refusal(OnJoint(Thrusting(("r", 90f, "j"), ("r", 90f, "j")), "j", (Up, -30f, 30f))); + Assert.Contains("joint j chain reaches 60 degrees of yaw", short1); + Assert.Contains("90 degree gimbal arc", short1); + // One degree over the reach is refused for a row of one as well, and the arc itself decides it. + Assert.Contains("reaches 90 degrees", Refusal(OnJoint(Thrusting((null, 91f, "j")), "j", (Up, -45f, 45f)))); + OnJoint(Thrusting((null, 90f, "j")), "j", (Up, -45f, 45f)).Validate(); + // Pitch adds nothing to the yaw a gimbal swings through. + Assert.Contains("reaches 0 degrees", Refusal(OnJoint(Thrusting(("r", 10f, "j")), "j", (Right, -180f, 180f)))); + } + + [Fact] + public void ARowOnAJointIsWholeAndAlone() + { + // A row whose members ride two joints. + var split = Thrusting(("r", 90f, "j"), ("r", 90f, "k")); + OnJoint(split, "j", (Up, -45f, 45f)); + OnJoint(split, "k", (Up, -45f, 45f)); + Assert.Contains("must ride it too", Refusal(split)); + // A row with a member on no joint. + Assert.Contains("must ride it too", Refusal(OnJoint(Thrusting(("r", 90f, "j"), ("r", 90f, null)), "j", (Up, -45f, 45f)))); + // A joint carrying two rows, and one carrying two rows of one. + Assert.Contains("carries thruster hardpoints t0 and t1 of different rows", + Refusal(OnJoint(Thrusting(("r", 90f, "j"), ("s", 90f, "j")), "j", (Up, -45f, 45f)))); + Assert.Contains("carries thruster hardpoints t0 and t1 of different rows", + Refusal(OnJoint(Thrusting((null, 90f, "j"), (null, 90f, "j")), "j", (Up, -45f, 45f)))); + // A row and a thruster of no row on one joint. + Assert.Contains("different rows", Refusal(OnJoint(Thrusting(("r", 90f, "j"), (null, 90f, "j")), "j", (Up, -45f, 45f)))); + // Each row on a joint of its own is fine. + var apart = Thrusting(("r", 90f, "j"), ("s", 90f, "k")); + OnJoint(apart, "j", (Up, -45f, 45f)); + OnJoint(apart, "k", (Up, -45f, 45f)); + apart.Validate(); + } + + [Fact] + public void ARadiatorStillMayNotRideAJoint() + { + var ship = OnJoint(Thrusting((null, 90f, "j")), "j", (Up, -180f, 180f)); + ship.Hull.Hardpoints.Single().Type = HardpointType.Radiator; + ship.Visual.Anchors.Single(anchor => anchor.Id == "t0").Role = "radiator-mesh"; + Assert.Contains("radiator-mesh anchor t0 may not ride a joint", Refusal(ship)); + } + + [Fact] + public void AGunAndAThrusterRowOnOneJointAreEachJudgedByTheirOwnArc() + { + // The gun rule is untouched: a gun and a thruster row each judged by their own arc against the one chain. + var ship = Armed("j"); + ship.Visual.Joints.Add(Joint("j", null, (Up, -45f, 45f))); + ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Transform == "g0").FiringArc = 90; + var thruster = ship.Hull.Hardpoints.Single(hardpoint => hardpoint.Type == HardpointType.Thruster); + thruster.FiringArc = 90; + ship.Visual.Anchors.Single(anchor => anchor.Id == thruster.Transform).Joint = "j"; + ship.Validate(); + thruster.FiringArc = 91; + Assert.Contains("90 degrees of yaw, short of the 91 degree gimbal arc", Refusal(ship)); + } + + // Row and Slew are persistent: a package or catalog written with them is read by key, so their positions are wire format. + [Fact] + public void RowAndSlewKeepTheirWirePositions() + { + var options = CultDocumentMessagePackSerialization.OptionsFor(typeof(HardpointData).Assembly); + var hardpoint = new HardpointData { Type = HardpointType.Thruster, Shape = new Shape(), Transform = "t", FiringArc = 40f, Row = "left" }; + var fields = MessagePackSerializer.Deserialize(MessagePackSerializer.Serialize(hardpoint, options), options); + Assert.Equal(8, fields.Length); + Assert.Equal(40f, Convert.ToSingle(fields[6])); + Assert.Equal("left", fields[7]); + Assert.Null(MessagePackSerializer.Deserialize(MessagePackSerializer.Serialize(new HardpointData { Shape = new Shape() }, options), options)[7]); + + var thruster = new ThrusterData(); + thruster.Thrust.Max = 5f; + thruster.Slew.Max = 90f; + var slew = MessagePackSerializer.Deserialize(MessagePackSerializer.Serialize(thruster, options), options); + Assert.Equal(7, slew.Length); + Assert.Equal(MessagePackSerializer.ConvertToJson(MessagePackSerializer.Serialize(thruster.Slew, options), options), + MessagePackSerializer.ConvertToJson(MessagePackSerializer.Serialize(slew[6], options), options)); + Assert.NotEqual(MessagePackSerializer.ConvertToJson(MessagePackSerializer.Serialize(thruster.Thrust, options), options), + MessagePackSerializer.ConvertToJson(MessagePackSerializer.Serialize(slew[6], options), options)); + } + + // A package written with a row reads back with it, and a fixed thruster with none reads back with none. + [Fact] + public async System.Threading.Tasks.Task ARowRoundTripsThroughAShipPackageAndNoRowStaysNone() + { + var path = Path.Combine(_directory.Path, "rows.cc"); + var ship = Thrusting(("r", 90f, null), ("r", 90f, null), (null, 0f, null)); + using (var cache = ShipAuthoringStore.Open(path, writable: true)) + { + ShipAuthoringStore.Write(cache, ship.Hull, ship.Visual); + await cache.FlushAsync(); + } + var (hull, _) = ShipAuthoringStore.Read(path); + Assert.Equal(new[] { "r", "r", null }, hull.Hardpoints.Select(hardpoint => hardpoint.Row)); + Assert.Equal(new[] { 90f, 90f, 0f }, hull.Hardpoints.Select(hardpoint => hardpoint.FiringArc)); + } } diff --git a/tests/Aetheria.Shared.Tests/ShipValidationTests.cs b/tests/Aetheria.Shared.Tests/ShipValidationTests.cs index 460918608..d9b984a35 100644 --- a/tests/Aetheria.Shared.Tests/ShipValidationTests.cs +++ b/tests/Aetheria.Shared.Tests/ShipValidationTests.cs @@ -226,8 +226,8 @@ public sealed class ShipValidationTests Add("joint-min-minus-181", s => Joint(s, "j", null, yaw, new[] { -181f }, new[] { 0f }), "must satisfy -180 <= Min <= Max <= 180"); Add("joint-parent-dangling", s => Joint(s, "j", "ghost", yaw, new[] { -1f }, new[] { 1f }), "has an unknown parent joint"); Add("joint-cycle", s => { Joint(s, "a", "b", yaw, new[] { -1f }, new[] { 1f }); Joint(s, "b", "a", yaw, new[] { -1f }, new[] { 1f }); }, "is on a parent cycle"); - Add("joint-on-a-thruster-mount", s => { Joint(s, "j", null, yaw, new[] { -1f }, new[] { 1f }); s.Visual.Anchors[4].Joint = "j"; }, "gimballed-thrusters"); - Add("joint-on-a-radiator-mount", s => { Joint(s, "j", null, yaw, new[] { -1f }, new[] { 1f }); s.Visual.Anchors[4].Role = "radiator-mesh"; s.Visual.Anchors[4].Joint = "j"; s.Hull.Hardpoints[0].Type = HardpointType.Radiator; }, "gimballed-thrusters"); + Add("joint-on-a-thruster-mount", s => { Joint(s, "j", null, yaw, new[] { -1f }, new[] { 1f }); s.Visual.Anchors[4].Joint = "j"; }, "a fixed thruster may not ride a joint"); + Add("joint-on-a-radiator-mount", s => { Joint(s, "j", null, yaw, new[] { -1f }, new[] { 1f }); s.Visual.Anchors[4].Role = "radiator-mesh"; s.Visual.Anchors[4].Joint = "j"; s.Hull.Hardpoints[0].Type = HardpointType.Radiator; }, "radiator-mesh anchor thruster.port may not ride a joint"); Add("joint-on-a-map-icon", s => { Joint(s, "j", null, yaw, new[] { -1f }, new[] { 1f }); s.Visual.Anchors[0].Joint = "j"; }, "may not name a joint"); Add("anchor-role-unknown", s => s.Visual.Anchors.Add(new ShipAnchor { Id = "x", Role = "engine", ModelNodeId = "x" }), "has unknown role 'engine'"); Add("anchor-role-null", s => s.Visual.Anchors.Add(new ShipAnchor { Id = "x", Role = null, ModelNodeId = "x" }), "has unknown role ''"); @@ -289,6 +289,23 @@ public sealed class ShipValidationTests Add("line-color-long", s => s.Visual.SchematicLines[0].Color = new[] { 1f, 1f, 1f, 1f, 1f }, "must be finite RGBA"); Add("line-color-nan", s => s.Visual.SchematicLines[0].Color[2] = float.NaN, "must be finite RGBA"); Add("line-color-infinite", s => s.Visual.SchematicLines[0].Color[3] = float.NegativeInfinity, "must be finite RGBA"); + // Thruster rows: the fixture's thruster joined by a second one at the hull's other cell, both in row "r". + void Row(ShipParts s, float arc, float otherArc, ItemRotation otherRotation = ItemRotation.Normal) + { + Mount(s).Row = "r"; + Mount(s).FiringArc = arc; + s.Hull.Hardpoints.Add(new HardpointData + { + Type = HardpointType.Thruster, Position = new int2(0, 0), Shape = new Shape(), Transform = "thruster.starboard", + Row = "r", FiringArc = otherArc, Rotation = otherRotation + }); + s.Visual.Anchors.Add(new ShipAnchor { Id = "thruster.starboard", Role = "thruster-emitter", ModelNodeId = "thruster-starboard" }); + } + Add("row-on-weapon", s => { Mount(s).Type = HardpointType.Energy; Mount(s).Row = "r"; }, "only a Thruster hardpoint may state a row"); + Add("row-rotation-mismatch", s => Row(s, 90, 90, ItemRotation.Reversed), "are in row r and must share Rotation and FiringArc"); + Add("row-arc-mismatch", s => Row(s, 90, 60), "are in row r and must share Rotation and FiringArc"); + Add("row-arc-zero", s => Row(s, 0, 0), "thruster row r must state a gimbal FiringArc above 0 and at most 360"); + Add("row-arc-above-a-turn", s => Row(s, 361, 361), "thruster row r must state a gimbal FiringArc above 0 and at most 360"); return cases; } }