feat(uxassist): optimize auto-construct planning

This commit is contained in:
soarqin committed 2026-09-13 22:30:10 +08:00
1 parent 0604308d8a
commit 82f6f53fa8
2 files changed
+357 -69

No files matched your search

+2 -1
View File
@@ -52,7 +52,7 @@ DSP_Mods/
| Mod | GUID | Description |
|-----|------|-------------|
| **LiveStreamAssist** | `org.soardev.livestreamassist` | UXAssist-based live-stream statistics display. The rebindable Ctrl+F8 shortcut starts or stops the feature; starting opens Production Statistics, then alternates with Dyson Sphere at random 15-30-second unscaled-time intervals. Closing the statistics window or ending the game session stops the feature without reopening the window. |
| **UXAssist** | `org.soardev.uxassist` | Core QoL mod and shared library. Window resize, profile-based saves, FPS control, factory/logistics/navigation/Dyson Sphere tweaks, UI improvements, config panel UI, and `Common/` + `UI/` widget library shared by other mods. The Factory tab's building-buffer controls include a comparison tip with the original game values. The Logistics tab can push auto-config values to all existing facilities of a type on the current planet (per-setting `Apply` and per-category `Apply All` buttons), and can set both product limits of every Orbital Collector across all loaded factories; logic is in `LogisticsPatch.Apply*`/`ForEach*` and wired in `UIConfigWindow`. Auto-construct uses forward sphere-cast probing, horizontal footprint-based detours, adaptive flight altitude, and stuck recovery while flying to construction ghosts. |
| **UXAssist** | `org.soardev.uxassist` | Core QoL mod and shared library. Window resize, profile-based saves, FPS control, factory/logistics/navigation/Dyson Sphere tweaks, UI improvements, config panel UI, and `Common/` + `UI/` widget library shared by other mods. The Factory tab's building-buffer controls include a comparison tip with the original game values. The Logistics tab can push auto-config values to all existing facilities of a type on the current planet (per-setting `Apply` and per-category `Apply All` buttons), and can set both product limits of every Orbital Collector across all loaded factories; logic is in `LogisticsPatch.Apply*`/`ForEach*` and wired in `UIConfigWindow`. Auto-construct uses a bounded construction-site planner, forward sphere-cast probing, horizontal footprint-based detours, adaptive flight altitude, and stuck recovery while flying to construction ghosts. |
| **CheatEnabler** | `org.soardev.cheatenabler` | Cheat pack (depends on UXAssist). Instant build, architect mode, infinite resources, power boosts, Dyson Sphere cheats with a bounded shell-count input (1–99,999), mecha invincibility, and more. |
| **LogisticMiner** | — | Makes logistic stations automatically mine ores and water from the current planet. |
| **HideTips** | — | Suppresses all tutorial popups, random tips, achievement/milestone cards, and skips the prologue cutscene. |
@@ -155,6 +155,7 @@ The sync is implemented as an inline PowerShell `Exec` step inside the `ZipMod`
- **Illegal Dyson shell generation:** Estimated triangle vertex counts mirror the original `DysonShell.GenerateGeometry` rasterization as closely as possible, but can still differ from the final frame-generated shell polygon at numerical boundaries. Max-output generation must treat `QuickAddDysonShell` failure as a candidate rejection and try the next candidate rather than assuming the estimate is exact.
- **Fail-soft patch application:** `PatchImpl<T>.Enable(true)` applies Harmony patches inside a try/catch. Runtime patching can fail through no fault of ours (Harmony re-runs other mods' transpilers on shared target methods), and an escaping exception would abort the calling `ConfigEntry.SettingChanged` delegate chain, desyncing config UI from config values. On failure it logs a `LogError` with the feature type name, rolls back via `UnpatchSelf()`, and leaves `_patch` null so a later `Enable(true)` can retry.
- **Convergent in-game UI state:** In-game overlay widgets whose visibility depends on game state (e.g. `AutoConstructUI`) must not rely solely on one-shot event-driven refreshes (`SettingChanged` handlers, patch `OnEnable`/`OnDisable`), because a thrown exception earlier in a delegate chain or a failed patch application silently drops the refresh. `AutoConstructUI.OnUpdate()` reconciles button visibility and the pending-construction count with actual game state every 30 frames (also effective while paused); the `AutoConstructPatch` postfix on `PlayerAction_Rts.GameTick` only implements the fly-to-target behavior, and `AutoConstructPatch.OnEnable` logs its visibility predicate inputs once per enable as a remote-diagnosis aid.
- **Auto-construct planner:** `AutoConstructPatch` keeps a construction-site plan while drones work, chooses among a fixed candidate set using local hash-space coverage and player/drone travel costs, and only replans on a coarse interval or after reaching a site. Candidate evaluation has fixed limits and uses allocation-free arrays; local construction checks also include ghosts whose materials can be delivered from the mecha package, so the planner does not abandon a site before the native item-placement pass can run.
- **Auto-navigation modes:** The legacy auto-navigation and the new navigation algorithm are mutually exclusive; legacy mode wins if both configuration values load as enabled. The shared `ToggleAutoCruise` key dispatches to only the selected implementation. New-navigation teardown is unconditional for configuration, target, capability, and lifecycle failures, while the manual-input option controls only user-override behavior. Its session state and cloned status label are reset through `GameLogic.OnGameEnd` and patch teardown. When the new algorithm is selected but inactive, the cloned status label prompts the player with the currently configured `ToggleAutoCruise` key; it shows the active status while navigation is running.
- **Auto-cruise flight input:** In the original `PlayerMove_Fly.GameTick`, `PlayerController.input0.y = 1` matches manual forward movement and `input1.y = 1` matches manual upward thrust. The legacy auto-cruise `Fly` handler must preserve these signs so the mecha leaves a planet with the same orientation and motion as manual control.
- **UI clone initialization and text measurement:** UXAssist UI factories and dependent mods' direct UI clones treat runtime DSP objects as style sources only; after `Instantiate`, they explicitly reset stateful `UIButton`, `Text`, `Image`, `InputField`, `Slider`, and `UIComboBox` fields that can otherwise carry source state. Use `UXAssist.UI.Util.GetPreferredWidth` for dynamic text width because it invalidates DSP's custom text-generator cache before reading `preferredWidth`; do not replace it with a generic `TextGenerator` or canvas-wide rebuild without validating the rendered result.
+355 -68
View File
@@ -12,13 +12,24 @@ internal static class FactoryBuildPatches
internal class AutoConstructPatch : PatchImpl<AutoConstructPatch>
{
private const long AutoConstructTickInterval = 15L;
private const float ConstructionStopMargin = 1.5f;
private const long PlannerTickInterval = 120L;
private const int MaxPlannerCandidates = 32;
private const int MaxImmediateBuildTargets = 120;
private const int MaxOverflowBuildTargets = 600;
private const int MaxPlannerEntriesPerCandidate = 4096;
private const int ItemAvailabilityCacheSize = 64;
private const float PlanArrivalDistance = 5f;
private const float CandidateMergeDistance = 6f;
private const float CoverageValuePerTarget = 100f;
private const float OverflowValuePerTarget = 12f;
private const float DroneDistanceCost = 0.3f;
private const float PlayerTravelCost = 1f;
private const float AvoidanceAltitude = 35f;
private const float AvoidanceClearance = 1.5f;
private const float StuckDistance = 1.5f;
private const int StuckTickThreshold = 45;
private static readonly float[] DetourSideOffsets = { 1f, -1f, 1f, -1f, 1f, -1f };
private static int _targetPrebuildId;
private static OrderNode _autoOrder;
private static Vector3 _lastPosition;
private static int _stuckTicks;
@@ -26,6 +37,21 @@ internal static class FactoryBuildPatches
private static bool _isAvoidingObstacle;
private static Vector3 _pendingWaypoint;
private static bool _hasPendingWaypoint;
private static Vector3 _constructionDestination;
private static bool _hasConstructionPlan;
private static bool _atConstructionDestination;
private static int _planAstroId;
private static long _lastPlanAttemptTick;
private static bool _hasPlanAttempted;
private static readonly Vector3[] PlannerCandidates = new Vector3[MaxPlannerCandidates];
private static readonly float[] PlannerCandidateDistanceSquared = new float[MaxPlannerCandidates];
private static int _plannerCandidateCount;
private static int _plannerNearestCandidateCount;
private static int _plannerSampleCount;
private static readonly int[] ItemAvailabilityProtoIds = new int[ItemAvailabilityCacheSize];
private static readonly int[] ItemAvailabilityCounts = new int[ItemAvailabilityCacheSize];
private static int _itemAvailabilityCount;
private static uint _plannerRandomState = 0x6D2B79F5u;
protected override void OnEnable()
{
@@ -61,8 +87,6 @@ internal static class FactoryBuildPatches
var planet = GameMain.localPlanet;
if (planet == null || !planet.factoryLoaded) return;
var factory = planet.factory;
var prebuildCount = factory.prebuildCount;
if (prebuildCount <= 0) return;
var player = __instance.player;
if (player.planetData != planet)
{
@@ -70,56 +94,44 @@ internal static class FactoryBuildPatches
return;
}
if (_targetPrebuildId != 0)
{
if (!TryGetPrebuild(factory, _targetPrebuildId, out var target) ||
target.itemRequired > 0 && player.package.GetItemCount(target.protoId) < target.itemRequired)
{
ResetNavigation();
}
else if (player.orders.orderCount > 0 ||
player.orders.currentOrder != null && player.orders.currentOrder != _autoOrder)
{
ResetNavigation();
}
}
if (_targetPrebuildId == 0)
{
if (prebuildCount <= player.mecha.constructionModule.buildTargetTotalCount ||
player.orders.orderCount > 0 || player.orders.currentOrder != null ||
player.controller.horzVelocity.sqrMagnitude > 0.01f)
{
return;
}
if (!TryFindTarget(factory, player, out _targetPrebuildId)) return;
_lastPosition = player.position;
_stuckTicks = 0;
_detourCount = 0;
_isAvoidingObstacle = false;
}
if (!TryGetPrebuild(factory, _targetPrebuildId, out var prebuild))
var currentOrder = player.orders.currentOrder;
if (HasManualInput(player) ||
currentOrder != null && currentOrder != _autoOrder ||
currentOrder == null && player.orders.orderCount > 0)
{
ClearAutoRoute(player);
ResetNavigation();
return;
}
var targetPosition = prebuild.pos;
var constructionStopDistance = Mathf.Max(2f, player.mecha.buildArea - ConstructionStopMargin);
if ((targetPosition - player.position).sqrMagnitude <= constructionStopDistance * constructionStopDistance)
var prebuildCount = factory.prebuildCount;
if (prebuildCount <= 0)
{
player.ClearOrders();
ClearAutoRoute(player);
ResetNavigation();
return;
}
if (player.movementState == EMovementState.Walk && player.mecha.thrusterLevel >= 1)
if (_hasConstructionPlan && _planAstroId != planet.astroId)
{
player.controller.actionWalk.SwitchToFly();
ClearAutoRoute(player);
ResetNavigation();
}
if (!_hasConstructionPlan)
{
if (!IsPlannerDue(timei) || !TryCreatePlan(factory, player, timei)) return;
}
else if (_atConstructionDestination && IsPlannerDue(timei))
{
if (HasLocalConstructionWork(factory, player)) return;
ClearAutoRoute(player);
ResetNavigation();
if (!TryCreatePlan(factory, player, timei)) return;
}
if (!_hasConstructionPlan) return;
if (_autoOrder != null && player.orders.currentOrder == null)
{
_autoOrder = null;
@@ -135,9 +147,24 @@ internal static class FactoryBuildPatches
}
}
if (!_hasPendingWaypoint &&
(player.position - _constructionDestination).sqrMagnitude <= PlanArrivalDistance * PlanArrivalDistance)
{
ClearAutoRoute(player);
_atConstructionDestination = true;
_stuckTicks = 0;
return;
}
_atConstructionDestination = false;
if (player.movementState == EMovementState.Walk && player.mecha.thrusterLevel >= 1)
{
player.controller.actionWalk.SwitchToFly();
}
if (_autoOrder == null)
{
IssueRoute(player, targetPosition, false);
IssueRoute(player, _constructionDestination, false);
return;
}
@@ -171,7 +198,7 @@ internal static class FactoryBuildPatches
_pendingWaypoint = Vector3.zero;
_hasPendingWaypoint = false;
player.controller.actionFly.targetAltitude = AvoidanceAltitude;
IssueRoute(player, targetPosition, true);
IssueRoute(player, _constructionDestination, true);
}
_stuckTicks = 0;
@@ -179,38 +206,286 @@ internal static class FactoryBuildPatches
}
}
private static bool TryFindTarget(PlanetFactory factory, Player player, out int targetId)
private static bool IsPlannerDue(long timei)
{
var prebuilds = factory.prebuildPool;
var minDistance = float.MaxValue;
targetId = 0;
for (var i = factory.prebuildCursor - 1; i > 0; i--)
{
ref var prebuild = ref prebuilds[i];
if (prebuild.id != i || prebuild.isDestroyed) continue;
if (prebuild.itemRequired > 0 && player.package.GetItemCount(prebuild.protoId) < prebuild.itemRequired) continue;
return !_hasPlanAttempted || timei < _lastPlanAttemptTick || timei - _lastPlanAttemptTick >= PlannerTickInterval;
}
var distance = (prebuild.pos - player.position).sqrMagnitude;
if (distance < minDistance)
private static bool TryCreatePlan(PlanetFactory factory, Player player, long timei)
{
_lastPlanAttemptTick = timei;
_hasPlanAttempted = true;
_hasConstructionPlan = false;
_atConstructionDestination = false;
_plannerCandidateCount = 0;
_plannerNearestCandidateCount = 0;
_plannerSampleCount = 0;
_itemAvailabilityCount = 0;
var buildArea = Mathf.Max(0f, player.mecha.buildArea);
if (buildArea < PlanArrivalDistance) return false;
CollectPlannerCandidates(factory, player, buildArea * buildArea);
if (_plannerCandidateCount == 0) return false;
var bestScore = float.MinValue;
var bestCoverageCount = 0;
var bestCandidate = Vector3.zero;
var buildAreaSquared = buildArea * buildArea;
for (var i = 0; i < _plannerCandidateCount; i++)
{
var score = EvaluatePlannerCandidate(factory, player, PlannerCandidates[i], buildAreaSquared, out var coverageCount);
if (coverageCount > 0 && score > bestScore)
{
minDistance = distance;
targetId = i;
bestScore = score;
bestCoverageCount = coverageCount;
bestCandidate = PlannerCandidates[i];
}
}
return targetId != 0;
if (bestCoverageCount == 0) return false;
_constructionDestination = bestCandidate;
_hasConstructionPlan = true;
_planAstroId = factory.planet.astroId;
_autoOrder = null;
_atConstructionDestination = false;
_stuckTicks = 0;
_detourCount = 0;
_isAvoidingObstacle = false;
_pendingWaypoint = Vector3.zero;
_hasPendingWaypoint = false;
_lastPosition = player.position;
return true;
}
private static bool TryGetPrebuild(PlanetFactory factory, int id, out PrebuildData prebuild)
private static void CollectPlannerCandidates(PlanetFactory factory, Player player, float buildAreaSquared)
{
if (id > 0 && id < factory.prebuildPool.Length)
var prebuilds = factory.prebuildPool;
for (var i = 1; i < factory.prebuildCursor; i++)
{
prebuild = factory.prebuildPool[id];
return prebuild.id == id && !prebuild.isDestroyed;
ref var prebuild = ref prebuilds[i];
if (prebuild.id != i || prebuild.isDestroyed || prebuild.builderLaunched) continue;
if (!HasRequiredItems(player, prebuild.protoId, prebuild.itemRequired)) continue;
var distanceSquared = (prebuild.pos - player.position).sqrMagnitude;
if (distanceSquared <= buildAreaSquared) continue;
AddPlannerCandidate(prebuild.pos, distanceSquared);
}
}
private static void AddPlannerCandidate(Vector3 position, float distanceSquared)
{
var mergeDistanceSquared = CandidateMergeDistance * CandidateMergeDistance;
for (var i = 0; i < _plannerCandidateCount; i++)
{
if ((PlannerCandidates[i] - position).sqrMagnitude <= mergeDistanceSquared) return;
}
prebuild = default;
return false;
if (_plannerNearestCandidateCount < MaxPlannerCandidates / 2)
{
var index = _plannerNearestCandidateCount++;
PlannerCandidates[index] = position;
PlannerCandidateDistanceSquared[index] = distanceSquared;
_plannerCandidateCount = Mathf.Max(_plannerCandidateCount, _plannerNearestCandidateCount);
return;
}
var farthestIndex = 0;
var farthestDistanceSquared = PlannerCandidateDistanceSquared[0];
for (var i = 1; i < _plannerNearestCandidateCount; i++)
{
if (PlannerCandidateDistanceSquared[i] > farthestDistanceSquared)
{
farthestIndex = i;
farthestDistanceSquared = PlannerCandidateDistanceSquared[i];
}
}
if (distanceSquared < farthestDistanceSquared)
{
PlannerCandidates[farthestIndex] = position;
PlannerCandidateDistanceSquared[farthestIndex] = distanceSquared;
return;
}
_plannerSampleCount++;
if (_plannerCandidateCount < MaxPlannerCandidates)
{
var index = _plannerCandidateCount++;
PlannerCandidates[index] = position;
PlannerCandidateDistanceSquared[index] = distanceSquared;
return;
}
var replacement = (int)(NextPlannerRandom() % (uint)_plannerSampleCount);
if (replacement < MaxPlannerCandidates / 2)
{
var index = MaxPlannerCandidates / 2 + replacement;
PlannerCandidates[index] = position;
PlannerCandidateDistanceSquared[index] = distanceSquared;
}
}
private static float EvaluatePlannerCandidate(PlanetFactory factory, Player player, Vector3 candidate, float buildAreaSquared, out int coverageCount)
{
coverageCount = 0;
var distanceSquaredSum = 0f;
var inspectedCount = 0;
var reachedScanLimit = false;
var prebuilds = factory.prebuildPool;
var hashSystem = factory.hashSystemStatic;
var hashPool = hashSystem.hashPool;
var bucketOffsets = hashSystem.bucketOffsets;
hashSystem.GetBucketIdxesInArea(candidate, Mathf.Sqrt(buildAreaSquared));
var activeBucketsCount = hashSystem.activeBucketsCount;
for (var bucketIndex = 0; bucketIndex < activeBucketsCount && !reachedScanLimit; bucketIndex++)
{
var bucket = hashSystem.activeBuckets[bucketIndex];
var bucketOffset = bucketOffsets[bucket];
var bucketCursor = hashSystem.bucketCursors[bucket];
for (var entryIndex = 0; entryIndex < bucketCursor; entryIndex++)
{
if (++inspectedCount > MaxPlannerEntriesPerCandidate)
{
reachedScanLimit = true;
break;
}
var hashEntry = hashPool[bucketOffset + entryIndex];
if (hashEntry == 0 || hashEntry >> 28 != 3) continue;
var prebuildId = hashEntry & 0xFFFFFFF;
if (prebuildId <= 0 || prebuildId >= prebuilds.Length) continue;
ref var prebuild = ref prebuilds[prebuildId];
if (prebuild.id != prebuildId || prebuild.isDestroyed || prebuild.builderLaunched) continue;
if (!HasRequiredItems(player, prebuild.protoId, prebuild.itemRequired)) continue;
var distanceSquared = (prebuild.pos - candidate).sqrMagnitude;
if (distanceSquared > buildAreaSquared) continue;
coverageCount++;
if (coverageCount <= MaxImmediateBuildTargets)
{
distanceSquaredSum += distanceSquared;
}
if (coverageCount >= MaxOverflowBuildTargets) break;
}
if (coverageCount >= MaxOverflowBuildTargets) break;
}
hashSystem.ClearActiveBuckets();
if (coverageCount == 0) return float.MinValue;
var immediateCount = Mathf.Min(coverageCount, MaxImmediateBuildTargets);
var overflowCount = Mathf.Min(Mathf.Max(0, coverageCount - MaxImmediateBuildTargets),
MaxOverflowBuildTargets - MaxImmediateBuildTargets);
var averageDistanceSquared = distanceSquaredSum / immediateCount;
var travelDistance = (candidate - player.position).magnitude;
return immediateCount * CoverageValuePerTarget +
overflowCount * OverflowValuePerTarget -
averageDistanceSquared * DroneDistanceCost -
travelDistance * PlayerTravelCost;
}
private static bool HasRequiredItems(Player player, int protoId, int itemRequired)
{
if (itemRequired <= 0) return true;
for (var i = 0; i < _itemAvailabilityCount; i++)
{
if (ItemAvailabilityProtoIds[i] == protoId)
{
return ItemAvailabilityCounts[i] >= itemRequired;
}
}
var itemCount = player.package.GetItemCount(protoId);
if (_itemAvailabilityCount < ItemAvailabilityCacheSize)
{
ItemAvailabilityProtoIds[_itemAvailabilityCount] = protoId;
ItemAvailabilityCounts[_itemAvailabilityCount] = itemCount;
_itemAvailabilityCount++;
}
return itemCount >= itemRequired;
}
private static uint NextPlannerRandom()
{
_plannerRandomState ^= _plannerRandomState << 13;
_plannerRandomState ^= _plannerRandomState >> 17;
_plannerRandomState ^= _plannerRandomState << 5;
return _plannerRandomState;
}
private static bool HasLocalConstructionWork(Player player)
{
var constructionModule = player.mecha.constructionModule;
return constructionModule.buildTargetTotalCount > 0 ||
constructionModule.droneIdleCount < constructionModule.droneCount;
}
private static bool HasLocalConstructionWork(PlanetFactory factory, Player player)
{
if (HasLocalConstructionWork(player)) return true;
var buildArea = Mathf.Max(0f, player.mecha.buildArea);
if (buildArea <= 0f) return false;
_itemAvailabilityCount = 0;
var prebuilds = factory.prebuildPool;
var hashSystem = factory.hashSystemStatic;
var hashPool = hashSystem.hashPool;
var bucketOffsets = hashSystem.bucketOffsets;
hashSystem.GetBucketIdxesInArea(player.position, buildArea);
var hasLocalTarget = false;
for (var bucketIndex = 0; bucketIndex < hashSystem.activeBucketsCount && !hasLocalTarget; bucketIndex++)
{
var bucket = hashSystem.activeBuckets[bucketIndex];
var bucketOffset = bucketOffsets[bucket];
var bucketCursor = hashSystem.bucketCursors[bucket];
for (var entryIndex = 0; entryIndex < bucketCursor; entryIndex++)
{
var hashEntry = hashPool[bucketOffset + entryIndex];
if (hashEntry == 0 || hashEntry >> 28 != 3) continue;
var prebuildId = hashEntry & 0xFFFFFFF;
if (prebuildId <= 0 || prebuildId >= prebuilds.Length) continue;
ref var prebuild = ref prebuilds[prebuildId];
if (prebuild.id != prebuildId || prebuild.isDestroyed || prebuild.builderLaunched) continue;
if (HasRequiredItems(player, prebuild.protoId, prebuild.itemRequired))
{
hasLocalTarget = true;
break;
}
}
}
hashSystem.ClearActiveBuckets();
return hasLocalTarget;
}
private static bool HasManualInput(Player player)
{
var input0 = player.controller.input0;
var input1 = player.controller.input1;
return Mathf.Abs(input0.x) > 0.01f || Mathf.Abs(input0.y) > 0.01f || input0.z > 0f ||
Mathf.Abs(input1.y) > 0.01f;
}
private static void ClearAutoRoute(Player player)
{
if (_autoOrder != null && player.orders.currentOrder == _autoOrder)
{
player.ClearOrders();
}
_autoOrder = null;
_pendingWaypoint = Vector3.zero;
_hasPendingWaypoint = false;
}
private static void IssueRoute(Player player, Vector3 targetPosition, bool keepAltitude)
@@ -218,8 +493,7 @@ internal static class FactoryBuildPatches
var direction = targetPosition - player.position;
if (direction.sqrMagnitude < 0.01f) return;
var target = targetPosition + direction.normalized * 6f;
_autoOrder = OrderNode.MoveTo(target);
_autoOrder = OrderNode.MoveTo(targetPosition);
player.Order(_autoOrder, false);
if (keepAltitude && player.movementState == EMovementState.Fly)
{
@@ -259,9 +533,13 @@ internal static class FactoryBuildPatches
var forwardExtent = Mathf.Min(GetProjectedExtent(obstacleBounds.extents, forward), 48f);
var sideOffset = Mathf.Max(6f, sideExtent + AvoidanceClearance + 2f);
var forwardOffset = Mathf.Max(5f, forwardExtent + AvoidanceClearance + 2f);
var sideOffsets = new[] { sideOffset, -sideOffset, sideOffset + 8f, -sideOffset - 8f, sideOffset + 16f, -sideOffset - 16f };
foreach (var lateralOffset in sideOffsets)
for (var offsetIndex = 0; offsetIndex < DetourSideOffsets.Length; offsetIndex++)
{
var lateralOffset = sideOffset * DetourSideOffsets[offsetIndex];
if (offsetIndex >= 2)
{
lateralOffset += 8f * (offsetIndex / 2) * DetourSideOffsets[offsetIndex];
}
var entry = SurfaceOffset(anchor, side * lateralOffset - forward * forwardOffset, planet.realRadius);
var exit = SurfaceOffset(anchor, side * lateralOffset + forward * forwardOffset, planet.realRadius);
if (IsPathClear(player, entry, altitude) &&
@@ -328,7 +606,6 @@ internal static class FactoryBuildPatches
private static void ResetNavigation()
{
_targetPrebuildId = 0;
_autoOrder = null;
_lastPosition = Vector3.zero;
_stuckTicks = 0;
@@ -336,6 +613,16 @@ internal static class FactoryBuildPatches
_isAvoidingObstacle = false;
_pendingWaypoint = Vector3.zero;
_hasPendingWaypoint = false;
_constructionDestination = Vector3.zero;
_hasConstructionPlan = false;
_atConstructionDestination = false;
_planAstroId = 0;
_lastPlanAttemptTick = 0;
_hasPlanAttempted = false;
_plannerCandidateCount = 0;
_plannerNearestCandidateCount = 0;
_plannerSampleCount = 0;
_itemAvailabilityCount = 0;
}
}