using System; using System.Collections.Generic; using System.Reflection.Emit; using BepInEx.Configuration; using CommonAPI.Systems; using HarmonyLib; using UnityEngine; using UnityEngine.UI; using UXAssist.Common; using UXAssist.Common.Patching; using Object = UnityEngine.Object; namespace UXAssist.Patches; public class PlayerPatch : PatchImpl { public static ConfigEntry EnhancedMechaForgeCountControlEnabled; public static ConfigEntry HideTipsForSandsChangesEnabled; public static ConfigEntry ShortcutKeysForStarsNameEnabled; private static PressKeyBind _showAllStarsNameKey; private static PressKeyBind _toggleAllStarsNameKey; private static PressKeyBind _autoDriveKey; public static ConfigEntry AutoCruiseEnabled { get; set; } = null!; public static ConfigEntry StopOnArrivalAndInput { get; set; } = null!; public static ConfigEntry UseWarper { get; set; } = null!; public static ConfigEntry UseWarperMinimalEnergy { get; set; } = null!; public static ConfigEntry UseWarperDistance { get; set; } = null!; public static ConfigEntry UseSpeedUp { get; set; } = null!; public static ConfigEntry UseSpeedUpMinimalEnergy { get; set; } = null!; public static ConfigEntry DFHiveFollowDistance { get; set; } = null!; public static ConfigEntry DFCarrierFollowDistance { get; set; } = null!; public static void Init() { _showAllStarsNameKey = KeyBindings.RegisterKeyBinding(new BuiltinKey { key = new CombineKey(0, CombineKey.ALT_COMB, ECombineKeyAction.OnceClick, false), conflictGroup = KeyBindConflict.UI | KeyBindConflict.KEYBOARD_KEYBIND, name = "ShowAllStarsName", canOverride = true } ); _toggleAllStarsNameKey = KeyBindings.RegisterKeyBinding(new BuiltinKey { key = new CombineKey((int)KeyCode.Tab, 0, ECombineKeyAction.OnceClick, false), conflictGroup = KeyBindConflict.UI | KeyBindConflict.KEYBOARD_KEYBIND, name = "ToggleAllStarsName", canOverride = true } ); _autoDriveKey = KeyBindings.RegisterKeyBinding(new BuiltinKey { key = new CombineKey((int)KeyCode.K, 0, ECombineKeyAction.OnceClick, true), conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND, name = "ToggleAutoCruise", canOverride = true }); EnhancedMechaForgeCountControlEnabled.SettingChanged += (_, _) => EnhancedMechaForgeCountControl.Enable(EnhancedMechaForgeCountControlEnabled.Value); HideTipsForSandsChangesEnabled.SettingChanged += (_, _) => HideTipsForSandsChanges.Enable(HideTipsForSandsChangesEnabled.Value); ShortcutKeysForStarsNameEnabled.SettingChanged += (_, _) => ShortcutKeysForStarsName.Enable(ShortcutKeysForStarsNameEnabled.Value); AutoNavigation.Init(); } public static void Start() { EnhancedMechaForgeCountControl.Enable(EnhancedMechaForgeCountControlEnabled.Value); HideTipsForSandsChanges.Enable(HideTipsForSandsChangesEnabled.Value); ShortcutKeysForStarsName.Enable(ShortcutKeysForStarsNameEnabled.Value); AutoNavigation.Enable(true); Enable(true); } public static void OnInputUpdate() { ShortcutKeysForStarsName.OnInputUpdate(); if (_autoDriveKey.keyValue) AutoNavigation.Toggle(); } public static void Uninit() { Enable(false); EnhancedMechaForgeCountControl.Enable(false); HideTipsForSandsChanges.Enable(false); ShortcutKeysForStarsName.Enable(false); AutoNavigation.Enable(false); } // Harmony transpiler: UIStarmapStar__OnLateUpdate_Transpiler // Target: UIStarmapStar._OnLateUpdate // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(UIStarmapStar), nameof(UIStarmapStar._OnLateUpdate))] private static IEnumerable UIStarmapStar__OnLateUpdate_Transpiler(IEnumerable instructions, ILGenerator generator) { var matcher = new CodeMatcher(instructions, generator); Label? jumpPos = null; matcher.MatchForward(false, new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapStar), nameof(UIStarmapStar.projectedCoord))), new CodeMatch(OpCodes.Ldarg_0) ).Advance(2).MatchForward(false, new CodeMatch(ci => ci.IsStloc()), new CodeMatch(ci => ci.IsLdloc()), new CodeMatch(ci => ci.Branches(out jumpPos)) ).Advance(3); var labels = matcher.Labels; matcher.Labels = []; matcher.CreateLabel(out var jumpPos2); matcher.InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ShowAllStarsNameStatus))).WithLabels(labels), new CodeInstruction(OpCodes.Ldc_I4_1), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brtrue, jumpPos.Value), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch.ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ForceShowAllStarsName))), new CodeInstruction(OpCodes.Brtrue, jumpPos.Value), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(Functions.UI.StarmapFilterUI), nameof(Functions.UI.StarmapFilterUI.ShowStarName))), new CodeInstruction(OpCodes.Ldarg_0), new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapStar), nameof(UIStarmapStar.star))), new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(StarData), nameof(StarData.index))), new CodeInstruction(OpCodes.Ldelem_I1), new CodeInstruction(OpCodes.Brtrue, jumpPos.Value), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ShowAllStarsNameStatus))), new CodeInstruction(OpCodes.Ldc_I4_2), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brfalse, jumpPos2), new CodeInstruction(OpCodes.Ldc_I4_0), new CodeInstruction(OpCodes.Stloc_1), new CodeInstruction(OpCodes.Br, jumpPos.Value) ); return matcher.InstructionEnumeration(); } private class EnhancedMechaForgeCountControl : PatchImpl { // Harmony transpiler: UIReplicatorWindow_OnOkButtonClick_Transpiler // Target: UIReplicatorWindow.OnOkButtonClick // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(UIReplicatorWindow), nameof(UIReplicatorWindow.OnOkButtonClick))] private static IEnumerable UIReplicatorWindow_OnOkButtonClick_Transpiler(IEnumerable instructions, ILGenerator generator) { var matcher = new CodeMatcher(instructions, generator); matcher.MatchForward(false, new CodeMatch(ci => ci.opcode == OpCodes.Ldc_I4_S && ci.OperandIs(10)) ); matcher.Repeat(m => m.SetAndAdvance(OpCodes.Ldc_I4, 1000)); return matcher.InstructionEnumeration(); } // Harmony transpiler: UIReplicatorWindow_OnPlusButtonClick_Transpiler // Target: UIReplicatorWindow.OnPlusButtonClick, UIReplicatorWindow.OnMinusButtonClick // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(UIReplicatorWindow), nameof(UIReplicatorWindow.OnPlusButtonClick))] [HarmonyPatch(typeof(UIReplicatorWindow), nameof(UIReplicatorWindow.OnMinusButtonClick))] private static IEnumerable UIReplicatorWindow_OnPlusButtonClick_Transpiler(IEnumerable instructions, ILGenerator generator) { var label1 = generator.DefineLabel(); var label2 = generator.DefineLabel(); var label3 = generator.DefineLabel(); var label4 = generator.DefineLabel(); var matcher = new CodeMatcher(instructions, generator); matcher.MatchForward(false, new CodeMatch(OpCodes.Ldloc_0), new CodeMatch(OpCodes.Ldc_I4_1), new CodeMatch(o => o.opcode == OpCodes.Add || o.opcode == OpCodes.Sub) ).Advance(1).RemoveInstruction().InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(VFInput), nameof(VFInput.control))), new CodeInstruction(OpCodes.Brfalse_S, label1), new CodeInstruction(OpCodes.Ldc_I4_S, 10), new CodeInstruction(OpCodes.Br_S, label4), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(VFInput), nameof(VFInput.shift))).WithLabels(label1), new CodeInstruction(OpCodes.Brfalse_S, label2), new CodeInstruction(OpCodes.Ldc_I4_S, 100), new CodeInstruction(OpCodes.Br_S, label4), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(VFInput), nameof(VFInput.alt))).WithLabels(label2), new CodeInstruction(OpCodes.Brfalse_S, label3), new CodeInstruction(OpCodes.Ldc_I4, 1000), new CodeInstruction(OpCodes.Br_S, label4), new CodeInstruction(OpCodes.Ldc_I4_1).WithLabels(label3) ).Labels.Add(label4); matcher.MatchForward(false, new CodeMatch(ci => ci.opcode == OpCodes.Ldc_I4_S && ci.OperandIs(10)) ); matcher.Repeat(m => m.SetAndAdvance(OpCodes.Ldc_I4, 1000)); return matcher.InstructionEnumeration(); } } private class HideTipsForSandsChanges : PatchImpl { // Harmony transpiler: Player_SetSandCount_Transpiler // Target: Player.SetSandCount // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(Player), nameof(Player.SetSandCount))] private static IEnumerable Player_SetSandCount_Transpiler(IEnumerable instructions, ILGenerator generator) { var matcher = new CodeMatcher(instructions, generator); matcher.MatchForward(false, new CodeMatch(OpCodes.Call, AccessTools.PropertySetter(typeof(Player), nameof(Player.sandCount))) ).Advance(1).Insert(new CodeInstruction(OpCodes.Ret)); return matcher.InstructionEnumeration(); } } public class ShortcutKeysForStarsName : PatchImpl { public static int ShowAllStarsNameStatus; public static bool ForceShowAllStarsName; public static bool ForceShowAllStarsNameExternal; public static void ToggleAllStarsName() { ShowAllStarsNameStatus = (ShowAllStarsNameStatus + 1) % 3; } public static void OnInputUpdate() { if (!UIRoot.instance.uiGame.starmap.active) return; var enabled = ShortcutKeysForStarsNameEnabled.Value; if (!enabled) { ForceShowAllStarsName = ForceShowAllStarsNameExternal; return; } if (_toggleAllStarsNameKey.keyValue) { ToggleAllStarsName(); } ForceShowAllStarsName = ForceShowAllStarsNameExternal || _showAllStarsNameKey.IsKeyPressing(); } [HarmonyPrefix] [HarmonyPatch(typeof(UIStarmap), nameof(UIStarmap._OnOpen))] private static void UIStarmap__OnOpen_Prefix() { ShowAllStarsNameStatus = 0; } /* // Harmony transpiler: UIStarmapPlanet__OnLateUpdate_Transpiler // Target: UIStarmapPlanet._OnLateUpdate // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet._OnLateUpdate))] private static IEnumerable UIStarmapPlanet__OnLateUpdate_Transpiler(IEnumerable instructions, ILGenerator generator) { var matcher = new CodeMatcher(instructions, generator); matcher.MatchForward(false, new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(OpCodes.Ldloc_3), new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.projected))) ); matcher.Advance(3); matcher.CreateLabel(out var jumpPos1); matcher.InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))), new CodeInstruction(OpCodes.Ldc_I4_2), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brfalse, jumpPos1), new CodeInstruction(OpCodes.Ldc_I4_0), new CodeInstruction(OpCodes.Stloc_3) ); matcher.MatchForward(false, new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.gameHistory))), new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.planet))), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PlanetData), nameof(PlanetData.id))), new CodeMatch(OpCodes.Callvirt, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.GetPlanetPin))), new CodeMatch(OpCodes.Ldc_I4_1), new CodeMatch(ci => ci.Branches(out _)), new CodeMatch(OpCodes.Ldc_I4_1), new CodeMatch(ci => ci.IsStloc()), new CodeMatch(ci => ci.Branches(out _)) ); matcher.CreateLabelAt(matcher.Pos + 8, out var jumpPos); var labels = matcher.Labels; matcher.Labels = []; matcher.InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))).WithLabels(labels), new CodeInstruction(OpCodes.Ldc_I4_1), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brtrue, jumpPos), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch), nameof(_showAllStarsNameKey))), new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(KeyBindings), nameof(KeyBindings.IsKeyPressing))), new CodeInstruction(OpCodes.Brtrue, jumpPos) ); return matcher.InstructionEnumeration(); } // Harmony transpiler: UIStarmapDFHive__OnLateUpdate_Transpiler // Target: UIStarmapDFHive._OnLateUpdate // Fallback: None — patch will fail loudly if the target method body changes. [HarmonyTranspiler] [HarmonyPatch(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive._OnLateUpdate))] private static IEnumerable UIStarmapDFHive__OnLateUpdate_Transpiler(IEnumerable instructions, ILGenerator generator) { var matcher = new CodeMatcher(instructions, generator); matcher.MatchForward(false, new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(ci => ci.IsLdloc()), new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.projected))) ); matcher.Advance(3); matcher.CreateLabel(out var jumpPos1); matcher.InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))), new CodeInstruction(OpCodes.Ldc_I4_2), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brfalse, jumpPos1), new CodeInstruction(OpCodes.Ldc_I4_0), new CodeInstruction(OpCodes.Stloc_S, 4) ); matcher.MatchForward(false, new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.gameHistory))), new CodeMatch(OpCodes.Ldarg_0), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.hive))), new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EnemyDFHiveSystem), nameof(EnemyDFHiveSystem.hiveStarId))), new CodeMatch(OpCodes.Ldc_I4, 1000000), new CodeMatch(OpCodes.Sub), new CodeMatch(OpCodes.Callvirt, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.GetHivePin))), new CodeMatch(OpCodes.Ldc_I4_1), new CodeMatch(ci => ci.Branches(out _)), new CodeMatch(OpCodes.Ldc_I4_1), new CodeMatch(ci => ci.IsStloc()), new CodeMatch(ci => ci.Branches(out _)) ); matcher.CreateLabelAt(matcher.Pos + 10, out var jumpPos); var labels = matcher.Labels; matcher.Labels = []; matcher.InsertAndAdvance( new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))).WithLabels(labels), new CodeInstruction(OpCodes.Ldc_I4_1), new CodeInstruction(OpCodes.Ceq), new CodeInstruction(OpCodes.Brtrue, jumpPos), new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch), nameof(_showAllStarsNameKey))), new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(KeyBindings), nameof(KeyBindings.IsKeyPressing))), new CodeInstruction(OpCodes.Brtrue, jumpPos) ); return matcher.InstructionEnumeration(); } */ } #region New navigation algorithm public class AutoNavigation : PatchImpl { private const double Epsilon = 1e-18; private const int DarkFogAstroIdStart = 1000000; private const int StarArriveThresholdRadius = 4000; private const int PlanetArriveThresholdRadius = 100; private const double StarSafeRedis = 2000; private const double PlanetSafeRedis = 2000; private const double HiveSafeRedis = GalaxyData.AU * 0.5; private const double FollowModeUseWarpDistance = GalaxyData.AU * 1.5; private const double ResidualCompensationMaxDistance = GalaxyData.AU * 0.5; private const double ResidualCompensationSpeedRatio = 0.5; private const double ResidualCompensationMinSpeed = 100; private const float WarpTurnDegreesPerTick = 1.6f; private static bool _enabled; private static Text _uiTipText; private static int _targetId; private static VectorLF3 _targetUniversePosition; private static VectorLF3 _targetUniverseVelocity; private static ESpaceGuideType _targetType; private static double _targetArriveThresholdRadius; private static readonly List Obstacles = new(64); private static bool _wasSailing; private static bool _followModeLock; private static bool _warpSteeringPending; private static Quaternion _warpHeadingBeforeRotation; private static VectorLF3 _warpTargetDirection; public static bool IsActive => _enabled; protected override void OnEnable( ) { StartG( ); global::UXAssist.Common.GameLogic.OnGameBegin += StartG; global::UXAssist.Common.GameLogic.OnGameEnd += ResetState; } protected override void OnDisable() { global::UXAssist.Common.GameLogic.OnGameBegin -= StartG; global::UXAssist.Common.GameLogic.OnGameEnd -= ResetState; ResetState(); if (_uiTipText != null) { Object.Destroy(_uiTipText.gameObject); _uiTipText = null; } } public static void Awake(ConfigFile config) { AutoCruiseEnabled = config.Bind( "Player", "AutoCruise", true, "Enable auto-cruise"); StopOnArrivalAndInput = config.Bind("Player", nameof(StopOnArrivalAndInput), true, "Stop auto-navigation on arrival or manual input"); UseWarper = config.Bind("Player", nameof(UseWarper), true, "Use warp during auto-navigation"); UseWarperMinimalEnergy = config.Bind( "Player", nameof(UseWarperMinimalEnergy), 800, new ConfigDescription("Minimum energy required to use warp (MJ)", new AcceptableValueRange(50, 1000))); UseWarperDistance = config.Bind("Player", nameof(UseWarperDistance), 2.0, new ConfigDescription("Minimum distance to use warp (AU)", new AcceptableValueRange(0.5, 20))); UseSpeedUp = config.Bind("Player", nameof(UseSpeedUp), true, "Use automatic acceleration"); UseSpeedUpMinimalEnergy = config.Bind( "Player", nameof(UseSpeedUpMinimalEnergy), 100, new ConfigDescription("Minimum energy required for automatic acceleration (MJ)", new AcceptableValueRange(50, 1000))); DFHiveFollowDistance = config.Bind( "Player", nameof(DFHiveFollowDistance), 0.5, new ConfigDescription("Dark Fog Hive follow distance (AU)", new AcceptableValueRange(0.1, 5))); DFCarrierFollowDistance = config.Bind( "Player", nameof(DFCarrierFollowDistance), 1000, new ConfigDescription("Dark Fog Carrier follow distance (m)", new AcceptableValueRange(100, 3000))); } public static void Init() { AutoCruiseEnabled.SettingChanged += NavigationModeChanged; } public static void StartG( ) { if (_uiTipText != null) { UpdateUiTip(); return; } if (UIRoot.instance?.uiGame?.generalTips?.modeText == null) return; Text originText = UIRoot.instance.uiGame.generalTips.modeText; _uiTipText = Object.Instantiate(originText, originText.transform.parent); _uiTipText.gameObject.SetActive(false); _uiTipText.rectTransform.anchoredPosition = new Vector2(0f, 160f); _uiTipText.fontStyle = FontStyle.Normal; UpdateUiTip(); } public static void Toggle() { if (!AutoCruiseEnabled.Value) return; if (_enabled) StopAutoNavigation(); else StartAutoNavigation( ); } private static void StartAutoNavigation( ) { if (DSPGame.IsMenuDemo || ! GameMain.isRunning) return; _enabled = true; ResetTargetState(); UIRealtimeTip.Popup(I18NKeys.AutoNavigationStarted.Translate(), sound: false); UpdateUiTip(); } private static void StopAutoNavigation(bool showTip = true) { bool wasEnabled = _enabled; _enabled = false; ResetTargetState(); if (wasEnabled && showTip && !DSPGame.IsMenuDemo && GameMain.isRunning) UIRealtimeTip.Popup(I18NKeys.AutoNavigationStopped.Translate(), sound: false); UpdateUiTip(); } private static void ResetTargetState( ) { _targetId = 0; _wasSailing = false; _followModeLock = false; _warpSteeringPending = false; _warpHeadingBeforeRotation = Quaternion.identity; _warpTargetDirection = default; _targetUniversePosition = default; _targetUniverseVelocity = default; _targetType = default; _targetArriveThresholdRadius = 0; Obstacles.Clear(); } private static void ResetState() { StopAutoNavigation(false); } private static void NavigationModeChanged(object sender, EventArgs args) { if (!AutoCruiseEnabled.Value) StopAutoNavigation(false); else UpdateUiTip(); global::UXAssist.Functions.UIFunctions.UpdateToggleAutoCruiseCheckButtonVisiblility(); } public static void UpdateUiTip() { if (_uiTipText == null) return; bool showTip = GameMain.isRunning && !DSPGame.IsMenuDemo && AutoCruiseEnabled.Value && (_enabled || HasNavigationTarget()); _uiTipText.gameObject.SetActive(showTip); if (!showTip) return; _uiTipText.text = _enabled ? I18NKeys.AutoNavigationActive.Translate() : string.Format(I18NKeys.AutoNavigationEnableHint.Translate(), KeyBindings.GetKeyBindingText(_autoDriveKey)); } public static bool HasNavigationTarget() { Player player = GameMain.mainPlayer; if (player == null || !TryResolveNavigationTarget(player, out NavigationTarget target)) return false; return target.Type != ESpaceGuideType.Planet || GameMain.localPlanet == null || target.Id != GameMain.localPlanet.astroId; } /// /// Performs precondition checks and refreshes the current navigation target. /// private static bool PreCheckAndRefreshTarget(Player player) { if (!AutoCruiseEnabled.Value) { StopAutoNavigation( ); return true; } if (!_enabled) return true; if (player.mecha.thrusterLevel < 2) { StopAutoNavigation( ); return true; } if (VFInput._pullUp.pressing || VFInput._pushDown.pressing || VFInput._moveLeft.pressing || VFInput._moveRight.pressing || VFInput._moveForward.pressing || VFInput._moveBackward.pressing) { if (StopOnArrivalAndInput.Value) StopAutoNavigation( ); return true; } if (!TryResolveNavigationTarget(player, out NavigationTarget target)) { StopAutoNavigation(); return true; } bool targetChanged = _targetId != target.Id || _targetType != target.Type; _targetId = target.Id; _targetType = target.Type; _targetUniversePosition = target.Position; _targetUniverseVelocity = target.Velocity; _targetArriveThresholdRadius = target.ArrivalRadius; if (targetChanged) { _followModeLock = false; } return false; } private static bool TryResolveNavigationTarget(Player player, out NavigationTarget target) { target = default; PlayerNavigation navigation = player.navigation; int indicatorAstroId = navigation.indicatorAstroId; if (indicatorAstroId > DarkFogAstroIdStart) { int astroIndex = indicatorAstroId - DarkFogAstroIdStart; if (astroIndex < 0 || astroIndex >= GameMain.spaceSector.astros.Length) return false; AstroData astro = GameMain.spaceSector.astros[astroIndex]; VectorLF3 localPosition = default; astro.VelocityU(ref localPosition, out Vector3 velocity); target = new NavigationTarget( indicatorAstroId, ESpaceGuideType.DFHive, astro.uPos, velocity, DFHiveFollowDistance.Value * GalaxyData.AU); return true; } if (indicatorAstroId != 0) { if (indicatorAstroId < 0 || indicatorAstroId >= GameMain.galaxy.astrosData.Length) return false; if (indicatorAstroId % 100 == 0) { StarData star = GameMain.galaxy.StarById(indicatorAstroId / 100); if (star == null) return false; target = new NavigationTarget( indicatorAstroId, ESpaceGuideType.Star, star.uPosition, default, GameMain.galaxy.astrosData[indicatorAstroId].uRadius + StarArriveThresholdRadius); } else { PlanetData planet = GameMain.galaxy.PlanetById(indicatorAstroId); if (planet == null) return false; target = new NavigationTarget( indicatorAstroId, ESpaceGuideType.Planet, planet.uPosition, default, planet.realRadius + PlanetArriveThresholdRadius); } return true; } int enemyId = navigation.indicatorEnemyId; if (enemyId <= 0 || enemyId >= GameMain.data.spaceSector.enemyPool.Length) return false; EnemyData enemy = GameMain.data.spaceSector.enemyPool[enemyId]; if (enemy.id != enemyId) return false; VectorLF3 localPositionForVelocity = enemy.pos; Vector3 localVelocity = enemy.vel; GameMain.data.spaceSector.TransformVelocityFromAstro_ref( enemy.astroId, out Vector3 enemyVelocity, ref localPositionForVelocity, ref localVelocity); GameMain.data.spaceSector.TransformFromAstro_ref(enemy.astroId, out VectorLF3 position, ref enemy.pos); target = new NavigationTarget(enemyId, ESpaceGuideType.DFCarrier, position, enemyVelocity, DFCarrierFollowDistance.Value); return true; } /// /// Steers toward the target while avoiding nearby obstacles. /// private static void SailToTarget(PlayerController controller, double distance) { CollectObstacles(); Player player = controller.player; double currentSpeed = player.uVelocity.magnitude; VectorLF3 preliminaryDir = SafeNorm(_targetUniversePosition - player.uPosition, default); VectorLF3 currentDir = SafeNorm(player.uVelocity, preliminaryDir); VectorLF3 targetDir = ComputeDirection(player.uPosition, currentDir, Obstacles); if (player.warping) UpdateSailVelocityAndRotation(controller, currentDir, currentSpeed, targetDir, currentSpeed); else { Mecha mecha = player.mecha; bool canWarp = UseWarper.Value && mecha.coreEnergy > UseWarperMinimalEnergy.Value * 1000 * 1000 && mecha.coreEnergy > mecha.warpStartPowerPerSpeed * controller.actionSail.maxWarpSpeed && player.mecha.thrusterLevel >= 3 && player.mecha.HasWarper( ) && GameMain.localPlanet == null && distance > GalaxyData.AU * UseWarperDistance.Value; if (canWarp && player.mecha.UseWarper( )) { UpdateSailVelocityAndRotation(controller, currentDir, currentSpeed, targetDir, currentSpeed); player.warpCommand = true; VFAudio.Create("warp-begin", player.transform, Vector3.zero, true); } else UpdateSailVelocityAndRotation(controller, currentDir, currentSpeed, targetDir, mecha.maxSailSpeed); } } private static void CollectObstacles() { Obstacles.Clear(); StarData localStar = GameMain.localStar; if (localStar == null) return; if (localStar.astroId != _targetId) Obstacles.Add(new Obstacle( localStar.uPosition, GameMain.galaxy.astrosData[localStar.astroId].uRadius, StarSafeRedis)); foreach (PlanetData planet in localStar.planets) { if (planet.astroId != _targetId) Obstacles.Add(new Obstacle(planet.uPosition, planet.realRadius, PlanetSafeRedis)); } if (_targetType == ESpaceGuideType.DFHive) return; EnemyDFHiveSystem hiveSys = GameMain.spaceSector.dfHives[localStar.index]; while (hiveSys != null) { if (hiveSys is { realized: true, hiveAstroId: > DarkFogAstroIdStart } && hiveSys.hiveAstroId != _targetId) { Obstacles.Add(new Obstacle( GameMain.spaceSector.astros[hiveSys.hiveAstroId - DarkFogAstroIdStart].uPos, 0, HiveSafeRedis)); } hiveSys = hiveSys.nextSibling; } } /// /// Computes a target direction with obstacle avoidance. /// /// Player position. /// Nearby obstacles. /// private static VectorLF3 ComputeDirection(VectorLF3 playerPos, VectorLF3 currentDirection, List obstacles) { VectorLF3 toTarget = _targetUniversePosition - playerPos; double toTargetSqr = toTarget.sqrMagnitude; if (toTargetSqr < Epsilon) return default; VectorLF3 baseDir = toTarget.normalized; foreach (Obstacle obstacle in obstacles) { double pathRadius = GetReachablePathRadius(obstacle); if (pathRadius <= 0.0) continue; VectorLF3 toObstacle = obstacle.Position - playerPos; double obstacleDistance = toObstacle.magnitude; if (obstacleDistance < pathRadius) return ComputeEscapeDirection(currentDirection, toObstacle, baseDir); if (IsSegmentBlocked(playerPos, _targetUniversePosition, obstacle.Position, pathRadius)) return ComputeTangentDirection(currentDirection, toObstacle, pathRadius, baseDir); } return baseDir; } private static double GetReachablePathRadius(Obstacle obstacle) { double targetClearance = (obstacle.Position - _targetUniversePosition).magnitude - _targetArriveThresholdRadius; return Math.Min(obstacle.PathRadius, targetClearance); } private static bool IsSegmentBlocked( VectorLF3 start, VectorLF3 end, VectorLF3 center, double pathRadius) { VectorLF3 segment = end - start; double segmentLength = segment.magnitude; if (segmentLength < Epsilon) return false; VectorLF3 toCenter = center - start; double projection = VectorLF3.Dot(toCenter, segment) / segmentLength; double closestDistance = projection <= 0.0 ? toCenter.magnitude : projection >= segmentLength ? (center - end).magnitude : Math.Sqrt(Math.Max(0.0, toCenter.sqrMagnitude - projection * projection)); return closestDistance < pathRadius; } private static VectorLF3 ComputeEscapeDirection(VectorLF3 currentDirection, VectorLF3 toObstacle, VectorLF3 fallback) { VectorLF3 outward = SafeNorm(-toObstacle, -fallback); VectorLF3 tangent = currentDirection - outward * VectorLF3.Dot(currentDirection, outward); tangent = SafeNorm(tangent, GetPerpendicularDirection(outward, VectorLF3.unit_y)); return SafeNorm(outward + tangent * 0.5, outward); } private static VectorLF3 ComputeTangentDirection( VectorLF3 currentDirection, VectorLF3 toObstacle, double pathRadius, VectorLF3 fallback) { double obstacleDistance = toObstacle.magnitude; if (obstacleDistance < Epsilon) return ComputeEscapeDirection(currentDirection, toObstacle, fallback); VectorLF3 radial = toObstacle / obstacleDistance; double cosAngle = Clamp(pathRadius / obstacleDistance, 0.0, 1.0); double sinAngle = Math.Sqrt(Math.Max(0.0, 1.0 - cosAngle * cosAngle)); VectorLF3 side = currentDirection - radial * VectorLF3.Dot(currentDirection, radial); if (side.sqrMagnitude < Epsilon) side = _targetUniverseVelocity - radial * VectorLF3.Dot(_targetUniverseVelocity, radial); if (side.sqrMagnitude < Epsilon) side = fallback - radial * VectorLF3.Dot(fallback, radial); if (side.sqrMagnitude < Epsilon) side = GetPerpendicularDirection(radial, VectorLF3.unit_y); return SafeNorm(radial * cosAngle + side.normalized * sinAngle, fallback); } /// /// Steers toward and follows a moving target without avoidance after close-range lock. /// Distance to the target. /// private static void FollowMovingTarget(PlayerController controller, double distance) { double arriveRadius = _targetArriveThresholdRadius; double exitLockRadius = arriveRadius * 1.05; double axialTolerance = arriveRadius * 0.8; double lateralTolerance = arriveRadius * 0.8; double axialSlowDownDistance = arriveRadius * 10; double lateralSlowDownDistance = arriveRadius * 5; Player player = controller.player; double mechaMaxSailSpeed = player.mecha.maxSailSpeed; VectorLF3 playerPos = player.uPosition; VectorLF3 playerVelocity = player.uVelocity; double playerSpeed = playerVelocity.magnitude; VectorLF3 targetPos = _targetUniversePosition; VectorLF3 targetVelocity = _targetUniverseVelocity; VectorLF3 toTarget = targetPos - playerPos; if (distance < Epsilon) return; VectorLF3 toTargetDir = toTarget / distance; VectorLF3 targetVelocityDir = SafeNorm(targetVelocity, toTargetDir); if (distance > FollowModeUseWarpDistance) { SailToTarget(controller, distance); return; } if (player.warping) { player.warpCommand = false; return; } if (distance > exitLockRadius) _followModeLock = false; else if (distance <= arriveRadius) _followModeLock = true; // Match the target velocity after entering the follow sphere. if (_followModeLock) { UpdateSailVelocityAndRotation( controller: controller, currentDir: SafeNorm(playerVelocity, targetVelocityDir), currentSpeed: playerSpeed, targetDir: targetVelocityDir, targetSpeed: targetVelocity.magnitude); return; } // Resolve the position error into axial and lateral components. double axialError = VectorLF3.Dot(toTarget, targetVelocityDir); VectorLF3 lateralVector = toTarget - targetVelocityDir * axialError; double lateralError = lateralVector.magnitude; VectorLF3 lateralDir = lateralError > Epsilon ? lateralVector / lateralError : default; // Axial approach. double axialEffectiveError = Math.Max(Math.Abs(axialError) - axialTolerance, 0.0); double axialApproachSpeed = mechaMaxSailSpeed * axialEffectiveError / (axialEffectiveError + axialSlowDownDistance); VectorLF3 axialDir = axialError >= 0 ? targetVelocityDir : - targetVelocityDir; // Lateral approach. double lateralEffectiveError = Math.Max(lateralError - lateralTolerance, 0.0); double lateralApproachSpeed = mechaMaxSailSpeed * lateralEffectiveError / (lateralEffectiveError + lateralSlowDownDistance); VectorLF3 relativeVelocityDesired = axialDir * axialApproachSpeed + lateralDir * lateralApproachSpeed; // Residual velocity compensation. if (distance > arriveRadius) { double cWeight = (distance - arriveRadius) / ResidualCompensationMaxDistance; cWeight = Clamp(cWeight, 0, 1); cWeight = cWeight * cWeight * (3.0 - 2.0 * cWeight); double cSpeed = player.mecha.maxSailSpeed * cWeight * ResidualCompensationSpeedRatio + ResidualCompensationMinSpeed; double dot = VectorLF3.Dot(relativeVelocityDesired, toTargetDir); if (dot < cSpeed) relativeVelocityDesired += toTargetDir * cSpeed; } // Combine target and approach velocities. VectorLF3 desiredVelocity = targetVelocity + relativeVelocityDesired; double desiredSpeed = Math.Min(desiredVelocity.magnitude, mechaMaxSailSpeed); VectorLF3 desiredDirection = SafeNorm(desiredVelocity, toTargetDir); VectorLF3 playerDir = SafeNorm(playerVelocity, desiredDirection); UpdateSailVelocityAndRotation( controller: controller, currentDir: playerDir, currentSpeed: playerSpeed, targetDir: desiredDirection, targetSpeed: desiredSpeed); } private static VectorLF3 SafeNorm(VectorLF3 vector, VectorLF3 fallback) => vector.sqrMagnitude < Epsilon ? fallback : vector.normalized; private static VectorLF3 GetPerpendicularDirection(VectorLF3 direction, VectorLF3 reference) { VectorLF3 perpendicular = reference - direction * VectorLF3.Dot(reference, direction); if (perpendicular.sqrMagnitude < Epsilon) perpendicular = VectorLF3.Cross(direction, VectorLF3.unit_x); if (perpendicular.sqrMagnitude < Epsilon) perpendicular = VectorLF3.Cross(direction, VectorLF3.unit_z); return perpendicular.sqrMagnitude < Epsilon ? VectorLF3.unit_y : perpendicular.normalized; } /// /// Updates sail acceleration, steering, rotation, and visual velocity. /// private static void UpdateSailVelocityAndRotation( PlayerController controller, VectorLF3 currentDir, double currentSpeed, VectorLF3 targetDir, double targetSpeed) { PlayerMove_Sail sail = controller.actionSail; Player player = controller.player; Mecha mecha = player.mecha; VectorLF3 currentVel = currentDir * currentSpeed; double desiredSpeed = Math.Min(targetSpeed, mecha.maxSailSpeed); double stepSpeed = currentSpeed; // Acceleration and braking. bool speedUp = UseSpeedUp.Value && mecha.coreEnergy > UseSpeedUpMinimalEnergy.Value * 1000 * 1000; if (speedUp && desiredSpeed > currentSpeed) { double dSpeed = Clamp(currentSpeed * 0.02, 7.0, sail.max_acc); dSpeed = Math.Min(dSpeed, desiredSpeed - currentSpeed); dSpeed = Math.Min(dSpeed, mecha.maxSailSpeed - currentSpeed); if (dSpeed > 0) stepSpeed = currentSpeed + dSpeed * sail.UseSailEnergy(dSpeed); } else if (desiredSpeed < currentSpeed) { VectorLF3 dVelocityBrake = currentVel * 0.008; sail.UseSailEnergy(ref dVelocityBrake, 1.5); stepSpeed = Math.Max(0, (currentVel - dVelocityBrake).magnitude); } _warpSteeringPending = player.warping && targetDir.sqrMagnitude > Epsilon; _warpHeadingBeforeRotation = player.uRotation; _warpTargetDirection = _warpSteeringPending ? targetDir : default; AdaptWarpSpeedControl(controller, targetDir); // Smooth velocity changes. VectorLF3 targetVelocity = targetDir * stepSpeed; float angle = Vector3.Angle(targetVelocity, currentVel); var t = 1.6f / Mathf.Max(10f, angle); VectorLF3 smoothedVelocity = SmoothVelocity(currentVel, targetVelocity, t, sail.sailPoser.targetURot * Vector3.up); VectorLF3 dVelocity = smoothedVelocity - currentVel; sail.UseSailEnergy(ref dVelocity, 0.36); VectorLF3 newVelocity = currentVel + dVelocity; sail.input_aff_1 = 1.0; player.uVelocity = newVelocity; UpdateRotation(controller: controller); } [HarmonyPatch(typeof(PlayerController), "UpdateRotation")] [HarmonyPostfix] private static void PlayerController_UpdateRotation_Postfix(PlayerController __instance) { if (!_enabled || !_warpSteeringPending) return; _warpSteeringPending = false; Player player = __instance.player; if (player == null || __instance.movementStateInFrame != EMovementState.Sail || !player.warping) return; Vector3 previousDirection = _warpHeadingBeforeRotation * Vector3.forward; Vector3 currentDirection = player.uRotation * Vector3.forward; Vector3 targetDirection = (Vector3)_warpTargetDirection; float appliedAngle = Vector3.Angle(previousDirection, currentDirection); float targetAngle = Vector3.Angle(currentDirection, targetDirection); float remainingAngle = Mathf.Min(targetAngle, Mathf.Max(0f, WarpTurnDegreesPerTick - appliedAngle)); if (remainingAngle < 0.01f) return; Vector3 turnAxis = GetStableTurnAxis(currentDirection, targetDirection); player.uRotation = Quaternion.AngleAxis(remainingAngle, turnAxis) * player.uRotation; } private static void AdaptWarpSpeedControl(PlayerController controller, VectorLF3 targetDir) { Player player = controller.player; if (!player.warping || VFInput._sailSpeedUp || controller.input0.y < 0f) return; Vector3 warpDirection = player.uRotation * Vector3.forward; float turnAngle = Vector3.Angle(warpDirection, targetDir); double turnSeverity = Clamp((turnAngle - 15.0) / 45.0, 0.0, 1.0); double targetControl = 1.0 - turnSeverity * turnSeverity * (3.0 - 2.0 * turnSeverity) * 0.8; double controlDelta = Clamp( targetControl - controller.actionSail.warpSpeedControl, -0.02, 0.02); controller.actionSail.warpSpeedControl = Clamp( controller.actionSail.warpSpeedControl + controlDelta, 0.2, 1.0); } private static VectorLF3 SmoothVelocity( VectorLF3 currentVelocity, VectorLF3 targetVelocity, float interpolation, VectorLF3 turnReference) { double currentMagnitude = currentVelocity.magnitude; double targetMagnitude = targetVelocity.magnitude; if (currentMagnitude < Epsilon && targetMagnitude < Epsilon) return VectorLF3.zero; Vector3 currentDirection = currentMagnitude >= Epsilon ? (Vector3)(currentVelocity / currentMagnitude) : (targetMagnitude >= Epsilon ? (Vector3)(targetVelocity / targetMagnitude) : Vector3.forward); Vector3 targetDirection = targetMagnitude >= Epsilon ? (Vector3)(targetVelocity / targetMagnitude) : currentDirection; Vector3 direction; if (Vector3.Dot(currentDirection, targetDirection) < -0.9999f) { float angle = Vector3.Angle(currentDirection, targetDirection); Vector3 axis = GetStableTurnAxis(currentDirection, (Vector3)turnReference); direction = Quaternion.AngleAxis(angle * interpolation, axis) * currentDirection; } else { direction = Vector3.Slerp(currentDirection, targetDirection, interpolation); } double magnitude = currentMagnitude + (targetMagnitude - currentMagnitude) * interpolation; return (VectorLF3)(direction.normalized * (float)magnitude); } private static Vector3 GetStableTurnAxis(Vector3 direction, Vector3 reference) { Vector3 projectedReference = reference - direction * Vector3.Dot(reference, direction); if (projectedReference.sqrMagnitude < 1e-10f) { projectedReference = Vector3.Cross(direction, Vector3.right); if (projectedReference.sqrMagnitude < 1e-10f) projectedReference = Vector3.Cross(direction, Vector3.up); } return Vector3.Cross(direction, projectedReference).normalized; } /// /// Updates player orientation. /// private static void UpdateRotation(PlayerController controller) { Player player = controller.player; PlayerMove_Sail sail = controller.actionSail; VectorLF3 newVelocity = player.uVelocity; // Use the camera up vector to stabilize orientation. if (newVelocity.magnitude > Epsilon) { VectorLF3 forward = newVelocity.normalized; Vector3 cameraUp = controller.actionSail.sailPoser.targetURot * Vector3.up; VectorLF3 cameraUpWorld = cameraUp; double dot = VectorLF3.Dot(cameraUpWorld, forward); VectorLF3 projectedUp = cameraUpWorld - forward * dot; Vector3 newUp; if (projectedUp.sqrMagnitude < Epsilon) { Vector3 cameraRight = controller.actionSail.sailPoser.targetURot * Vector3.right; newUp = Vector3.Cross(cameraRight, forward); if (newUp.sqrMagnitude < Epsilon) newUp = Vector3.up; else newUp.Normalize( ); } else newUp = ((Vector3)projectedUp).normalized; Quaternion targetRot = Quaternion.LookRotation(forward, newUp); float rotAngle = Quaternion.Angle(player.uRotation, targetRot); float rotT = Mathf.Min(0.15f, 10f / Mathf.Max(10f, rotAngle)); player.uRotation = Quaternion.Slerp(player.uRotation, targetRot, rotT); } // Keep visual velocity consistent with universal velocity. PlanetData localPlanet = GameMain.localPlanet; if (localPlanet != null) { VectorLF3 planetVel = localPlanet.GetUniversalVelocityAtLocalPoint(GameMain.gameTime, player.position); sail.visual_uvel = newVelocity - planetVel; } else sail.visual_uvel = newVelocity; } private static double Clamp(double value, double min, double max) => value < min ? min : value > max ? max : value; // Harmony transpiler: PlayerController_GameTick_Transpiler // Target: PlayerController.GameTick // Fallback: Return the original instructions if the insertion point cannot be found. [HarmonyTranspiler] [HarmonyPatch(typeof(PlayerController), nameof(PlayerController.GameTick))] private static IEnumerable PlayerController_GameTick_Transpiler( IEnumerable instructions, ILGenerator generator) { var original = new List(instructions); var matcher = new CodeMatcher(original, generator); matcher.MatchForward( false, new CodeMatch( OpCodes.Callvirt, AccessTools.Method(typeof(BuildModel), nameof(BuildModel.EarlyGameTickIgnoreActive))) ).Advance(1).InsertAndAdvance( new CodeInstruction(OpCodes.Ldarg_0), Transpilers.EmitDelegate((PlayerController controller) => { EMovementState movementState = controller.movementStateInFrame; if (movementState is not (EMovementState.Walk or EMovementState.Drift or EMovementState.Fly)) return; if (PreCheckAndRefreshTarget(controller.player) || DetermineTargetLocal( )) return; if (movementState == EMovementState.Fly) { controller.input1.y = 1f; controller.input0.y = 1f; } else controller.input0.z = 1f; }) ); return matcher.Finish(original, UXAssist.Logger, nameof(PlayerController_GameTick_Transpiler)); // Detect arrival while walking or flying. static bool DetermineTargetLocal( ) { if (_targetId != 0 && (_targetType != ESpaceGuideType.Planet || GameMain.localPlanet?.astroId != _targetId)) return false; StopAutoNavigation( ); return true; } } [HarmonyPatch(typeof(PlayerMove_Sail), nameof(PlayerMove_Sail.GameTick)), HarmonyPostfix] // ReSharper disable once InconsistentNaming private static void PlayerMoveSailPostfix(PlayerMove_Sail __instance) { PlayerController controller = __instance.controller; Player player = __instance.player; if (PreCheckAndRefreshTarget(player)) return; bool isSailing = controller.movementStateInFrame == EMovementState.Sail; bool enteredSailing = isSailing && !_wasSailing; _wasSailing = isSailing; if (!isSailing) return; VectorLF3 playerPos = player.uPosition; VectorLF3 targetVector = _targetUniversePosition - playerPos; double distance = targetVector.magnitude; if (enteredSailing && targetVector.sqrMagnitude >= Epsilon) __instance.sailPoser.targetURotWanted = Quaternion.LookRotation(targetVector); // ReSharper disable once SwitchStatementMissingSomeEnumCasesNoDefault switch (_targetType) { case ESpaceGuideType.Star: case ESpaceGuideType.Planet: // Stop after reaching a fixed target. if (distance < _targetArriveThresholdRadius) { if (player.warping) player.warpCommand = false; StopAutoNavigation( ); return; } SailToTarget(controller, distance); break; case ESpaceGuideType.DFHive: case ESpaceGuideType.DFCarrier: FollowMovingTarget(controller, distance); break; } } } private readonly struct NavigationTarget( int id, ESpaceGuideType type, VectorLF3 position, VectorLF3 velocity, double arrivalRadius) { public int Id { get; } = id; public ESpaceGuideType Type { get; } = type; public VectorLF3 Position { get; } = position; public VectorLF3 Velocity { get; } = velocity; public double ArrivalRadius { get; } = arrivalRadius; } private readonly struct Obstacle(VectorLF3 position, double radius, double safetyMargin) { public VectorLF3 Position { get; } = position; public double Radius { get; } = radius; public double PathRadius { get; } = radius + safetyMargin; } #endregion }