mirror of
https://github.com/soarqin/DSP_Mods.git
synced 2026-11-19 17:05:20 +08:00
feat(uxassist): optimize auto-construct planning
This commit is contained in:
1 parent
0604308d8a
commit
82f6f53fa8
2 files changed
+357
-69
No files matched your search
@@ -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.
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user