Hump yard stuff

Mapify/CarLabeler/CreateLabel.cs

@@ -0,0 +1,137 @@
+using CommsRadioAPI;
+using DV;
+using UnityEngine;
+
+namespace Mapify.CarLabeler
+{
+    public class CreateLabel: SubState
+    {
+        private TrainCar pointedCar;
+        private RaycastHit[] hits = new RaycastHit[5];
+
+        private static bool isSetup;
+        private static GameObject trainHighlighter;
+        private static Material selectionMaterial;
+        private static MeshRenderer trainHighlighterRender;
+
+        public CreateLabel(YardDestination aDestination) :
+            base(aDestination,
+                $"Point at a car and click to label it.\n" +
+                    $"{aDestination.StationName()}-{aDestination.YardID}-{aDestination.TrackNumber}"
+            )
+        {
+            if(isSetup) return;
+            DoSetup();
+        }
+
+        private static void DoSetup()
+        {
+            var deleter = (CommsRadioCarDeleter)ControllerAPI.GetVanillaMode(VanillaMode.Clear);
+
+            if (deleter == null)
+            {
+                Mapify.LogError($"{nameof(CreateLabel)}: Could not get deleter");
+                return;
+            }
+
+            trainHighlighter = deleter.trainHighlighter;
+            selectionMaterial = deleter.selectionMaterial;
+            trainHighlighterRender = deleter.trainHighlighterRender;
+
+            isSetup = true;
+        }
+
+        public override AStateBehaviour OnAction(CommsRadioUtility utility, InputAction action)
+        {
+            switch (action)
+            {
+                case InputAction.Activate:
+                    MarkCar(utility);
+                    goto default; //C#, why...
+                default:
+                    return new CreateLabel(destination);
+            }
+        }
+
+        private void MarkCar(CommsRadioUtility utility)
+        {
+            if (pointedCar == null){
+                utility.PlaySound(VanillaSoundCommsRadio.Warning);
+                return;
+            }
+
+            var labelComponent = pointedCar.gameObject.GetComponent<YardDestinationComponent>();
+            if (labelComponent == null)
+            {
+                labelComponent = pointedCar.gameObject.AddComponent<YardDestinationComponent>();
+            }
+
+            labelComponent.Setup(destination);
+            utility.PlaySound(VanillaSoundCommsRadio.Confirm);
+        }
+
+        public override AStateBehaviour OnUpdate(CommsRadioUtility utility)
+        {
+            TrainCar car = null;
+
+            // Why does the direction need to be downward? I would expect forward.
+            if(Physics.RaycastNonAlloc(utility.SignalOrigin.position, -utility.SignalOrigin.up, hits, maxDistance: 100f) > 0)
+            {
+                foreach (var hit in hits)
+                {
+                    if (hit.transform == null) continue;
+
+                    car = TrainCar.Resolve(hit.transform.root);
+                    if (car == null) continue;
+
+                    Mapify.LogDebug($"hit car {car.gameObject.name}");
+                    Mapify.LogDebug($"layer: {car.gameObject.layer}");
+                    break;
+                }
+            }
+
+            PointToCar(car, utility);
+            return this;
+        }
+
+        private void PointToCar(TrainCar car, CommsRadioUtility utility)
+        {
+            if (pointedCar == car) return;
+
+            pointedCar = car;
+            ClearHighlightCar();
+
+            if (pointedCar == null) return;
+
+            HighlightCar(pointedCar);
+            utility.PlaySound(VanillaSoundCommsRadio.HoverOver);
+        }
+
+        private static void HighlightCar(TrainCar car)
+        {
+            Mapify.LogDebug($"{nameof(HighlightCar)}: {car}");
+
+            trainHighlighterRender.material = selectionMaterial;
+            var transform = trainHighlighter.transform;
+            var bounds = car.Bounds;
+            var vector3_1 = bounds.size + CommsRadioCarDeleter.HIGHLIGHT_BOUNDS_EXTENSION;
+            transform.localScale = vector3_1;
+            var vector3_2 = car.transform.up * (trainHighlighter.transform.localScale.y / 2f);
+            var forward = car.transform.forward;
+            bounds = car.Bounds;
+            double z = bounds.center.z;
+            var vector3_3 = forward * (float) z;
+            trainHighlighter.transform.SetPositionAndRotation(car.transform.position + vector3_2 + vector3_3, car.transform.rotation);
+            trainHighlighter.SetActive(true);
+            trainHighlighter.transform.SetParent(car.transform, true);
+        }
+
+        private static void ClearHighlightCar()
+        {
+            Mapify.LogDebug($"{nameof(ClearHighlightCar)}");
+
+            trainHighlighter.SetActive(false);
+            trainHighlighter.transform.SetParent(null);
+        }
+    }
+}

Mapify/CarLabeler/SelectStation.cs

@@ -0,0 +1,50 @@
+using CommsRadioAPI;
+
+namespace Mapify.CarLabeler
+{
+    public class SelectStation: SubState
+    {
+        public SelectStation(YardDestination aDestination) :
+            base(aDestination, $"station:\n{aDestination.StationName()}"
+        )
+        {}
+
+        public override AStateBehaviour OnAction(CommsRadioUtility utility, InputAction action)
+        {
+            switch (action)
+            {
+                case InputAction.Activate:
+                    utility.PlaySound(VanillaSoundCommsRadio.Confirm);
+                    return new SelectYard(destination);
+                case InputAction.Up:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousStation(1);
+                case InputAction.Down:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousStation(-1);
+                default:
+                    return new SelectStation(destination);
+            }
+        }
+
+        private AStateBehaviour NextOrPreviousStation(int stationIndexDelta)
+        {
+            var allStations = StationController.allStations;
+            var stationIndex = 0;
+
+            for (int index = 0; index < allStations.Count; index++)
+            {
+                if (allStations[index].stationInfo.YardID != destination.StationID) continue;
+
+                stationIndex = index;
+                break;
+            }
+
+            stationIndex = Utils.Misc.BetterModulo(stationIndex + stationIndexDelta, allStations.Count);
+
+            destination.StationID = allStations[stationIndex].stationInfo.YardID;
+
+            return new SelectStation(destination);
+        }
+    }
+}

Mapify/CarLabeler/SelectTrack.cs

@@ -0,0 +1,61 @@
+using System.Linq;
+using CommsRadioAPI;
+using Mapify.Utils;
+
+namespace Mapify.CarLabeler
+{
+    public class SelectTrack: SubState
+    {
+        public SelectTrack(YardDestination aDestination) :
+            base(aDestination, $"track: {aDestination.TrackNumber}"
+        )
+        {}
+
+        public override AStateBehaviour OnAction(CommsRadioUtility utility, InputAction action)
+        {
+            switch (action)
+            {
+                case InputAction.Activate:
+                    utility.PlaySound(VanillaSoundCommsRadio.Confirm);
+                    return new CreateLabel(destination);
+                case InputAction.Up:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousTrack(1);
+                case InputAction.Down:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousTrack(-1);
+                default:
+                    return new SelectTrack(destination);
+            }
+        }
+
+        private AStateBehaviour NextOrPreviousTrack(int trackIndexDelta)
+        {
+            //TODO cache this
+            var yardTracks = RailTrackRegistry.Instance
+                .GetTrackNumbersOfSubYard(destination.StationID, destination.YardID)
+                .ToList();
+
+            Mapify.LogDebug("yardTracks:");
+            foreach (var track in yardTracks)
+            {
+                Mapify.LogDebug(track);
+            }
+
+            var trackIndex = 0;
+
+            for (int index = 0; index < yardTracks.Count; index++)
+            {
+                if (yardTracks[index] != destination.TrackNumber) continue;
+
+                trackIndex = index;
+                break;
+            }
+
+            trackIndex = Utils.Misc.BetterModulo(trackIndex + trackIndexDelta, yardTracks.Count);
+            destination.TrackNumber = yardTracks[trackIndex];
+
+            return new SelectTrack(destination);
+        }
+    }
+}

Mapify/CarLabeler/SelectYard.cs

@@ -0,0 +1,59 @@
+using System.Linq;
+using CommsRadioAPI;
+using Mapify.Utils;
+
+namespace Mapify.CarLabeler
+{
+    public class SelectYard: SubState
+    {
+        public SelectYard(YardDestination aDestination) :
+            base(aDestination, $"yard: {aDestination.YardID}"
+        )
+        {}
+
+        public override AStateBehaviour OnAction(CommsRadioUtility utility, InputAction action)
+        {
+            switch (action)
+            {
+                case InputAction.Activate:
+                    utility.PlaySound(VanillaSoundCommsRadio.Confirm);
+                    return new SelectTrack(destination);
+                case InputAction.Up:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousYard(1);
+                case InputAction.Down:
+                    utility.PlaySound(VanillaSoundCommsRadio.Switch);
+                    return NextOrPreviousYard(-1);
+                default:
+                    return new SelectYard(destination);
+            }
+        }
+
+        private AStateBehaviour NextOrPreviousYard(int yardIndexDelta)
+        {
+            //TODO cache this
+            var stationYards = RailTrackRegistry.Instance.GetSubYardIDsOfYard(destination.StationID).ToList();
+
+            Mapify.LogDebug("stationYards:");
+            foreach (var yard in stationYards)
+            {
+                Mapify.LogDebug(yard);
+            }
+
+            var yardIndex = 0;
+
+            for (int index = 0; index < stationYards.Count; index++)
+            {
+                if (stationYards[index] != destination.YardID) continue;
+
+                yardIndex = index;
+                break;
+            }
+
+            yardIndex = Utils.Misc.BetterModulo(yardIndex + yardIndexDelta, stationYards.Count);
+            destination.YardID = stationYards[yardIndex];
+
+            return new SelectYard(destination);
+        }
+    }
+}

Mapify/CarLabeler/Start.cs

@@ -0,0 +1,32 @@
+using CommsRadioAPI;
+
+namespace Mapify.CarLabeler
+{
+    public class Start: AStateBehaviour
+    {
+        public Start() : base(new CommsRadioState(
+            titleText: SubState.LABELER_TITLE,
+            contentText: "enable yard car labeler?"
+            ))
+        {}
+
+        public override AStateBehaviour OnAction(CommsRadioUtility utility, InputAction action)
+        {
+            switch (action)
+            {
+                case InputAction.Activate:
+                    utility.PlaySound(VanillaSoundCommsRadio.ModeEnter);
+                    return new SelectStation(SetupDestination());
+                default:
+                    return new Start();
+            }
+        }
+
+        private static YardDestination SetupDestination()
+        {
+            var aDestination = Mapify.Settings.lastUsedLabel;
+            YardDestination.Validate(ref aDestination);
+            return aDestination;
+        }
+    }
+}

Mapify/CarLabeler/SubState.cs

@@ -0,0 +1,22 @@
+using CommsRadioAPI;
+using DV;
+
+namespace Mapify.CarLabeler
+{
+    public abstract class SubState: AStateBehaviour
+    {
+        public const string LABELER_TITLE = "car labeler";
+
+        protected YardDestination destination;
+
+        protected SubState(YardDestination aDestination, string contentText_) :
+            base(new CommsRadioState(
+                titleText: LABELER_TITLE,
+                buttonBehaviour: ButtonBehaviourType.Override,
+                contentText: contentText_
+            ))
+        {
+            destination = aDestination;
+        }
+    }
+}