perf(uxassist): speed up miner search and honor native clearances

Cache which seeds block each candidate for the replacement, repacking and refill passes, skip candidates that can no longer join a greedy pass, test repack option pairs only when reached, and reuse nearby nodes and obstacles across rotations at each candidate position. Recorded snapshots replay to identical layouts in sequential and parallel modes.

Exclude positions the game refuses near the landing capsule and EM Rail Ejectors, and keep buried nodes near Dark Fog Planetary Bases buried, as native reform does. Remove the unused placement limit, duplicate ground checks and per-miner GPU buffer syncs; debug snapshots move to schema 3 with clearance rejections.
This commit is contained in:
soarqin committed 2026-10-21 01:14:36 +08:00
1 parent 20a3a3a37e
commit bc8a0b0189
7 files changed
+499 -397

No files matched your search

@@ -14,7 +14,7 @@ internal static class MinerPlacementDebug
[Serializable]
internal sealed class Snapshot
{
public int schema = 2;
public int schema = 3;
public string algorithm = "parallel-repack-v5-pose-exploration-min3-unlimited-stock";
public int minimumCoverage = MinerPlacementSolver.MinimumCoverage;
public string version, gameVersion, startedUtc, outcome, error;
@@ -105,8 +105,6 @@ internal static class MinerPlacementDebug
{
public string name;
public int candidateCount, passes, score;
// Unlimited-stock snapshots may omit the legacy placement cap.
public int limit = int.MaxValue;
public long elapsedMilliseconds, searchMilliseconds;
public int[] selected;
}
@@ -122,7 +120,7 @@ internal static class MinerPlacementDebug
[Serializable]
internal sealed class Rejections
{
public int attempted, range, mixedType, noCoverage, veinCollision, buildingCollision, ground;
public int attempted, range, clearance, mixedType, noCoverage, veinCollision, buildingCollision, ground;
}
public static float[] Vector(Vector3 value) => [value.x, value.y, value.z];
@@ -29,7 +29,7 @@ internal static class MinerPlacementGeometry
}
}
public static bool Intersects(Box a, Box b)
public static bool Intersects(in Box a, in Box b)
{
var delta = b.Center - a.Center;
// Reject distant individual colliders before the full separating-axis test. This
@@ -50,7 +50,7 @@ internal static class MinerPlacementGeometry
!Separated(Vector3.Cross(a.Z, b.Z), delta, a, b);
}
private static bool Separated(Vector3 axis, Vector3 delta, Box a, Box b)
private static bool Separated(Vector3 axis, Vector3 delta, in Box a, in Box b)
{
if (axis.sqrMagnitude < 1e-10f) return false;
var radius = a.Extents.x * Mathf.Abs(Vector3.Dot(axis, a.X)) +
@@ -62,7 +62,7 @@ internal static class MinerPlacementGeometry
return Mathf.Abs(Vector3.Dot(delta, axis)) > radius;
}
public static bool Intersects(Box box, ColliderData collider)
public static bool Intersects(in Box box, ColliderData collider)
{
switch (collider.shape)
{
+270 -206
View File
@@ -10,6 +10,8 @@ namespace UXAssist.Functions.Factory;
internal sealed class MinerPlacementSolver
{
internal const int MinimumCoverage = 3;
// Coordinated repacking replaces at most this many nearby miners at once.
private const int RegionSize = 3;
public static int WorkerCount => GetWorkerCount(Environment.ProcessorCount);
internal static int GetWorkerCount(int processors) => Math.Min(4, Math.Max(0, processors / 2));
@@ -35,25 +37,23 @@ internal sealed class MinerPlacementSolver
_nodeCount = nodeCount;
}
public IEnumerator Search(int passes) => Search(int.MaxValue, passes);
public IEnumerator Search(int passes) => Search(passes, 0, CancellationToken.None);
public IEnumerator Search(int limit, int passes) => Search(limit, passes, 0, CancellationToken.None);
public Task SearchAsync(int limit, int passes, CancellationToken cancellationToken, int workers = 4)
public Task SearchAsync(int passes, CancellationToken cancellationToken, int workers = 4)
{
workers = Math.Min(workers, WorkerCount);
if (workers <= 0) throw new InvalidOperationException("Use the main-thread search when no worker is available.");
// The caller must not mutate candidates until this task has completed. Workers only
// read captured geometry; no Unity physics, game objects, or factory state is accessed.
return Task.Run(() => Drain(Search(limit, passes, workers, cancellationToken), cancellationToken), cancellationToken);
return Task.Run(() => Drain(Search(passes, workers, cancellationToken), cancellationToken), cancellationToken);
}
private IEnumerator Search(int limit, int passes, int workers, CancellationToken cancellationToken)
private IEnumerator Search(int passes, int workers, CancellationToken cancellationToken)
{
// Keep a burial-free baseline, explore different packing orders, then try individual
// replacements before the more expensive coordinated neighborhood search.
var results = new SearchResult[passes];
var work = RunBatch(passes, pass => GreedyPass(limit, pass, null, results, pass, cancellationToken), workers, cancellationToken);
var work = RunBatch(passes, pass => GreedyPass(pass, null, null, -1, results, pass, cancellationToken), workers, cancellationToken);
while (work.MoveNext()) yield return null;
foreach (var result in results) Accept(result);
// Candidate indices shift when a few poses become invalid. Duplicated poses also
@@ -65,24 +65,33 @@ internal sealed class MinerPlacementSolver
if ((i & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
keys[i] = PoseKey(_candidates[i]);
}
var additional = new SearchResult[Math.Max(0, passes - 2)];
work = RunBatch(additional.Length,
index => GreedyPass(limit, index + 2, null, additional, index, cancellationToken, keys), workers, cancellationToken);
while (work.MoveNext()) yield return null;
foreach (var result in additional) Accept(result);
var seeds = new List<Candidate>(Best);
results = new SearchResult[seeds.Count];
work = RunBatch(seeds.Count, index => GreedyPass(limit, passes + index, seeds, results, index, cancellationToken), workers, cancellationToken);
results = new SearchResult[Math.Max(0, passes - 2)];
work = RunBatch(results.Length, index => GreedyPass(index + 2, keys, null, -1, results, index, cancellationToken), workers, cancellationToken);
while (work.MoveNext()) yield return null;
foreach (var result in results) Accept(result);
var repair = Repack(limit, workers, cancellationToken);
while (repair.MoveNext()) yield return null;
var seeds = new SeedCollisions(_candidates.Count);
work = TrackBest(seeds, workers, cancellationToken);
while (work.MoveNext()) yield return null;
results = new SearchResult[seeds.Seeds.Count];
work = RunBatch(results.Length, index => GreedyPass(0, null, seeds, index, results, index, cancellationToken), workers, cancellationToken);
while (work.MoveNext()) yield return null;
foreach (var result in results) Accept(result);
for (var round = 0; round < 2 && Best.Count > 0; round++)
{
work = TrackBest(seeds, workers, cancellationToken);
while (work.MoveNext()) yield return null;
work = Repack(seeds, workers, cancellationToken);
while (work.MoveNext()) yield return null;
if (ReferenceEquals(seeds.Seeds, Best)) break;
}
// A local replacement can open space beyond its neighborhood. Saturate the full
// candidate set once more, preserving every selected miner's minimum coverage.
var refill = new SearchResult[1];
work = GreedyPass(limit, 0, new List<Candidate>(Best), refill, 0, cancellationToken, keepAllSeeds: true);
work = TrackBest(seeds, workers, cancellationToken);
while (work.MoveNext()) yield return null;
Accept(refill[0]);
results = new SearchResult[1];
work = GreedyPass(0, null, seeds, -1, results, 0, cancellationToken);
while (work.MoveNext()) yield return null;
Accept(results[0]);
}
private static uint PoseKey(Candidate candidate)
@@ -94,17 +103,30 @@ internal sealed class MinerPlacementSolver
return unchecked((uint)(x * 73856093 ^ z * 19349663 ^ yaw * 83492791));
}
private IEnumerator GreedyPass(int limit, int pass, List<Candidate> seeds, SearchResult[] results, int resultIndex,
CancellationToken cancellationToken, uint[] keys = null, bool keepAllSeeds = false)
// Without seeds, fill an empty layout in the exploration order of pass, keyed by candidate
// index or by keys. With seeds, keep every seed except removed (all when negative) and
// refill greedily.
private IEnumerator GreedyPass(int pass, uint[] keys, SeedCollisions seeds, int removed, SearchResult[] results, int resultIndex,
CancellationToken cancellationToken)
{
var selected = new List<Candidate>();
var buried = new bool[_nodeCount];
var uses = new int[_nodeCount];
var score = 0;
var layout = new Layout(_nodeCount);
// Selected miners already proven compatible with each candidate, or -1 once it cannot
// join. Layouts and burials only grow during a pass, so every exclusion is permanent.
var verified = new int[_candidates.Count];
if (seeds != null)
for (var i = 0; i < seeds.Count && selected.Count < limit; i++)
if (keepAllSeeds || i != resultIndex) Add(seeds[i], selected, buried, uses, ref score);
while (selected.Count < limit)
{
for (var i = 0; i < seeds.Seeds.Count; i++)
if (i != removed) layout.Add(seeds.Seeds[i]);
for (var i = 0; i < verified.Length; i++)
verified[i] = (removed >= 0 && ReferenceEquals(_candidates[i], seeds.Seeds[removed])) || !seeds.AllowsWithout(i, removed)
? -1 : layout.Selected.Count;
}
else if (pass == 0)
{
for (var i = 0; i < verified.Length; i++)
if (_candidates[i].Buried.Length != 0) verified[i] = -1;
}
while (true)
{
Candidate chosen = null;
var priority = float.NegativeInfinity;
@@ -115,31 +137,43 @@ internal sealed class MinerPlacementSolver
cancellationToken.ThrowIfCancellationRequested();
yield return null;
}
if (verified[i] < 0) continue;
var candidate = _candidates[i];
if (seeds != null && !keepAllSeeds && ReferenceEquals(candidate, seeds[resultIndex])) continue;
if (seeds == null && pass == 0 && candidate.Buried.Length != 0) continue;
var gain = Gain(candidate, buried, uses, out var coverage);
if (coverage < MinimumCoverage || gain <= 0) continue;
// Deterministic exploration without depending on the game's random stream.
var hash = (keys == null ? unchecked((uint)((i + 1) * 73856093)) : keys[i]) ^
unchecked((uint)((pass + 1) * 19349663 ^ (selected.Count + 1) * 83492791));
hash ^= hash >> 16;
hash = unchecked(hash * 0x7feb352dU);
hash ^= hash >> 15;
hash = unchecked(hash * 0x846ca68bU);
hash ^= hash >> 16;
var jitter = pass is 0 or 1 || seeds != null ? 1f : 0.65f + (hash & 65535) / 65535f * 0.7f;
var value = gain * jitter - candidate.Buried.Length * 0.0001f;
if (value > priority && Fits(candidate, selected) && PreservesCoverage(candidate, selected, buried))
var gain = layout.Gain(candidate, out var coverage);
if (coverage < MinimumCoverage)
{
chosen = candidate;
priority = value;
verified[i] = -1;
continue;
}
if (gain <= 0) continue;
var jitter = 1f;
if (seeds == null && pass > 1)
{
// Deterministic exploration without depending on the game's random stream.
var hash = (keys?[i] ?? unchecked((uint)((i + 1) * 73856093))) ^
unchecked((uint)((pass + 1) * 19349663 ^ (layout.Selected.Count + 1) * 83492791));
hash ^= hash >> 16;
hash = unchecked(hash * 0x7feb352dU);
hash ^= hash >> 15;
hash = unchecked(hash * 0x846ca68bU);
hash ^= hash >> 16;
jitter = 0.65f + (hash & 65535) / 65535f * 0.7f;
}
var value = gain * jitter - candidate.Buried.Length * 0.0001f;
if (value <= priority) continue;
if (!layout.FitsFrom(candidate, verified[i]) || !layout.PreservesCoverage(candidate))
{
verified[i] = -1;
continue;
}
verified[i] = layout.Selected.Count;
chosen = candidate;
priority = value;
}
if (chosen == null) break;
Add(chosen, selected, buried, uses, ref score);
layout.Add(chosen);
}
results[resultIndex] = new SearchResult(selected, score, CountBuried(selected));
results[resultIndex] = new SearchResult(layout.Selected, layout.Score, layout.BuriedCount);
}
private static void Drain(IEnumerator work, CancellationToken cancellationToken)
@@ -169,6 +203,8 @@ internal sealed class MinerPlacementSolver
public int Score = score, BuriedCount = buriedCount;
}
// Accept replaces Best with a new list only for a strictly better layout, so an unchanged
// reference means no improvement.
private void Accept(SearchResult result)
{
if (!IsBetter(result.Score, result.BuriedCount, result.Selected.Count, BestScore, _bestBuriedCount, Best.Count)) return;
@@ -183,98 +219,141 @@ internal sealed class MinerPlacementSolver
// A legal crossing may require moving several miners together. Removing only one and
// greedily refilling cannot escape that local optimum. Repack up to three nearby miners
// with bounded, spatially diverse alternatives, enumerating their compatible combinations.
private IEnumerator Repack(int limit, int workers, CancellationToken cancellationToken)
private IEnumerator Repack(SeedCollisions seeds, int workers, CancellationToken cancellationToken)
{
for (var round = 0; round < 2 && Best.Count > 0; round++)
var regions = Regions(seeds.Seeds);
var results = new SearchResult[regions.Count];
for (var i = 0; i < results.Length; i++) results[i] = new SearchResult(Best, BestScore, _bestBuriedCount);
var work = RunBatch(regions.Count, index => RepackRegion(seeds, regions[index], results[index], cancellationToken), workers, cancellationToken);
while (work.MoveNext()) yield return null;
// Merge in the original region order, independent of worker completion order.
foreach (var result in results) Accept(result);
}
// Each miner alone, with each of its three nearest neighbors, and with each pair of them.
private static List<(int, int, int)> Regions(List<Candidate> seeds)
{
var regions = new List<(int, int, int)>();
var unique = new HashSet<(int, int, int)>();
for (var pivot = 0; pivot < seeds.Count; pivot++)
{
var seeds = new List<Candidate>(Best);
var initialScore = BestScore;
var initialBuried = _bestBuriedCount;
var regions = new HashSet<(int, int, int)>();
for (var pivot = 0; pivot < seeds.Count; pivot++)
Add((pivot, -1, -1));
var neighbors = new List<int>();
for (var i = 0; i < seeds.Count; i++) if (i != pivot) neighbors.Add(i);
neighbors.Sort((a, b) => (seeds[a].Position - seeds[pivot].Position).sqrMagnitude.CompareTo(
(seeds[b].Position - seeds[pivot].Position).sqrMagnitude));
if (neighbors.Count > 3) neighbors.RemoveRange(3, neighbors.Count - 3);
foreach (var neighbor in neighbors) Add((Math.Min(pivot, neighbor), Math.Max(pivot, neighbor), -1));
for (var a = 0; a < neighbors.Count; a++)
for (var b = a + 1; b < neighbors.Count; b++)
{
regions.Add((pivot, -1, -1));
var neighbors = new List<int>();
for (var i = 0; i < seeds.Count; i++) if (i != pivot) neighbors.Add(i);
neighbors.Sort((a, b) => (seeds[a].Position - seeds[pivot].Position).sqrMagnitude.CompareTo(
(seeds[b].Position - seeds[pivot].Position).sqrMagnitude));
if (neighbors.Count > 3) neighbors.RemoveRange(3, neighbors.Count - 3);
foreach (var neighbor in neighbors) regions.Add((Math.Min(pivot, neighbor), Math.Max(pivot, neighbor), -1));
for (var a = 0; a < neighbors.Count; a++)
for (var b = a + 1; b < neighbors.Count; b++)
{
var indices = new[] { pivot, neighbors[a], neighbors[b] };
Array.Sort(indices);
regions.Add((indices[0], indices[1], indices[2]));
}
var indices = new[] { pivot, neighbors[a], neighbors[b] };
Array.Sort(indices);
Add((indices[0], indices[1], indices[2]));
}
// Every region keeps a subset of the same seeds. Compute each candidate/seed
// collision once, instead of repeating the SAT tests for every overlapping region.
var fits = new bool[seeds.Count][];
var cacheWork = RunBatch(seeds.Count, index => CacheSeedFits(index, seeds[index], fits, cancellationToken), workers, cancellationToken);
while (cacheWork.MoveNext()) yield return null;
var regionList = new List<(int, int, int)>(regions);
var results = new SearchResult[regionList.Count];
for (var i = 0; i < results.Length; i++) results[i] = new SearchResult(Best, BestScore, _bestBuriedCount);
var regionWork = RunBatch(regionList.Count,
index => RepackRegion(limit, seeds, regionList[index], fits, results[index], cancellationToken), workers, cancellationToken);
while (regionWork.MoveNext()) yield return null;
// Merge in the original region order, independent of worker completion order.
foreach (var result in results) Accept(result);
if (BestScore == initialScore && _bestBuriedCount == initialBuried && Best.Count == seeds.Count) break;
}
}
return regions;
private IEnumerator CacheSeedFits(int index, Candidate seed, bool[][] fits, CancellationToken cancellationToken)
{
var row = new bool[_candidates.Count];
for (var i = 0; i < row.Length; i++)
void Add((int, int, int) region)
{
if ((i & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
row[i] = PairFits(_candidates[i], seed);
if (unique.Add(region)) regions.Add(region);
}
fits[index] = row;
}
private IEnumerator RepackRegion(int limit, List<Candidate> seeds, (int, int, int) region, bool[][] fits,
SearchResult result, CancellationToken cancellationToken)
private static bool InRegion(int seed, (int, int, int) region) => seed == region.Item1 || seed == region.Item2 || seed == region.Item3;
// Seed passes, repacking regions and the final refill keep a subset of the same seeds. Find
// the seeds that block each candidate once per seed set, instead of repeating the SAT tests.
private sealed class SeedCollisions(int candidateCount)
{
var state = new PartialLayout(_nodeCount);
public List<Candidate> Seeds;
// Counts saturate past RegionSize: no single removal can free such a candidate.
public readonly byte[] Counts = new byte[candidateCount];
public readonly int[] Blockers = new int[candidateCount * RegionSize];
// A negative seed removes nothing, so only unblocked candidates qualify.
public bool AllowsWithout(int candidate, int seed) =>
Counts[candidate] == 0 || Counts[candidate] == 1 && Blockers[candidate * RegionSize] == seed;
public bool Allows(int candidate, (int, int, int) region)
{
var count = Counts[candidate];
if (count > RegionSize) return false;
for (var i = 0; i < count; i++)
if (!InRegion(Blockers[candidate * RegionSize + i], region)) return false;
return true;
}
}
// Best is replaced, never mutated, so an unchanged reference keeps the collisions valid.
private IEnumerator TrackBest(SeedCollisions seeds, int workers, CancellationToken cancellationToken)
{
if (ReferenceEquals(seeds.Seeds, Best)) yield break;
seeds.Seeds = Best;
var chunks = Math.Max(1, workers * 4);
var size = (_candidates.Count + chunks - 1) / chunks;
var work = RunBatch(chunks, chunk => FindCollisions(seeds, chunk * size, Math.Min(_candidates.Count, (chunk + 1) * size), cancellationToken),
workers, cancellationToken);
while (work.MoveNext()) yield return null;
}
private IEnumerator FindCollisions(SeedCollisions seeds, int start, int end, CancellationToken cancellationToken)
{
for (var i = start; i < end; i++)
{
if (((i - start) & 31) == 0)
{
cancellationToken.ThrowIfCancellationRequested();
yield return null;
}
var count = 0;
for (var seed = 0; seed < seeds.Seeds.Count && count <= RegionSize; seed++)
{
if (PairFits(_candidates[i], seeds.Seeds[seed])) continue;
if (count < RegionSize) seeds.Blockers[i * RegionSize + count] = seed;
count++;
}
seeds.Counts[i] = (byte)count;
}
}
private IEnumerator RepackRegion(SeedCollisions seeds, (int, int, int) region, SearchResult result, CancellationToken cancellationToken)
{
var layout = new Layout(_nodeCount);
var removed = new List<Candidate>();
var centerX = 0f;
var centerZ = 0f;
for (var i = 0; i < seeds.Count; i++)
for (var i = 0; i < seeds.Seeds.Count; i++)
{
if (i != region.Item1 && i != region.Item2 && i != region.Item3) state.Add(seeds[i]);
var seed = seeds.Seeds[i];
if (!InRegion(i, region)) layout.Add(seed);
else
{
removed.Add(seeds[i]);
centerX += seeds[i].X;
centerZ += seeds[i].Z;
removed.Add(seed);
centerX += seed.X;
centerZ += seed.Z;
}
}
centerX /= removed.Count;
centerZ /= removed.Count;
var slots = Math.Min(3, limit - state.Selected.Count);
if (slots <= 0) yield break;
var buckets = new List<(Candidate Candidate, int Gain)>[8];
for (var b = 0; b < buckets.Length; b++) buckets[b] = [];
for (var i = 0; i < _candidates.Count; i++)
{
if ((i & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
if ((i & 127) == 0)
{
cancellationToken.ThrowIfCancellationRequested();
yield return null;
}
var candidate = _candidates[i];
if (candidate.Covered.Length < MinimumCoverage) continue;
var nearby = false;
foreach (var seed in removed)
if ((candidate.Position - seed.Position).sqrMagnitude <= 36f) { nearby = true; break; }
if (!nearby) continue;
var legal = true;
for (var j = 0; j < seeds.Count; j++)
if (j != region.Item1 && j != region.Item2 && j != region.Item3 && !fits[j][i]) { legal = false; break; }
if (!legal) continue;
if (!nearby || !seeds.Allows(i, region)) continue;
var angle = Math.Atan2(candidate.Z - centerZ, candidate.X - centerX) + Math.PI;
var bucket = Math.Min(7, (int)(angle * 4 / Math.PI));
buckets[bucket].Add((candidate, state.Gain(candidate)));
buckets[bucket].Add((candidate, layout.Gain(candidate, out _)));
}
var options = new List<Candidate>(removed);
foreach (var bucket in buckets)
@@ -297,56 +376,101 @@ internal sealed class MinerPlacementSolver
}
}
options.Sort((a, b) => b.Covered.Length.CompareTo(a.Covered.Length));
var compatible = new bool[options.Count, options.Count];
// Pruning skips most option pairs, so test their collisions only when reached.
var pairs = new sbyte[options.Count * options.Count];
var operations = 0;
for (var i = 0; i < options.Count; i++)
for (var j = i + 1; j < options.Count; j++)
{
if ((operations++ & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
compatible[i, j] = PairFits(options[i], options[j]);
}
for (var i = 0; i < options.Count; i++)
{
state.Add(options[i]);
if (!state.HasMinimumCoverage()) { state.RemoveLast(); continue; }
Consider(state, result);
for (var j = i + 1; slots > 1 && j < options.Count; j++)
if (!layout.CanAdd(options[i])) continue;
layout.Add(options[i]);
Consider(layout, result);
for (var j = i + 1; j < options.Count; j++)
{
if ((operations++ & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
if (state.RawScore + (slots - 1) * options[j].Covered.Length < result.Score) break;
if (!compatible[i, j]) continue;
state.Add(options[j]);
if (!state.HasMinimumCoverage()) { state.RemoveLast(); continue; }
Consider(state, result);
for (var k = j + 1; slots > 2 && k < options.Count; k++)
if ((operations++ & 127) == 0)
{
if ((operations++ & 127) == 0) { cancellationToken.ThrowIfCancellationRequested(); yield return null; }
if (state.RawScore + options[k].Covered.Length < result.Score) break;
if (!compatible[i, k] || !compatible[j, k]) continue;
state.Add(options[k]);
if (state.HasMinimumCoverage()) Consider(state, result);
state.RemoveLast();
cancellationToken.ThrowIfCancellationRequested();
yield return null;
}
state.RemoveLast();
if (layout.RawScore + (RegionSize - 1) * options[j].Covered.Length < result.Score) break;
if (!Compatible(i, j) || !layout.CanAdd(options[j])) continue;
layout.Add(options[j]);
Consider(layout, result);
for (var k = j + 1; k < options.Count; k++)
{
if ((operations++ & 127) == 0)
{
cancellationToken.ThrowIfCancellationRequested();
yield return null;
}
if (layout.RawScore + options[k].Covered.Length < result.Score) break;
if (!Compatible(i, k) || !Compatible(j, k) || !layout.CanAdd(options[k])) continue;
layout.Add(options[k]);
Consider(layout, result);
layout.RemoveLast();
}
layout.RemoveLast();
}
state.RemoveLast();
layout.RemoveLast();
}
bool Compatible(int first, int second)
{
var slot = first * options.Count + second;
if (pairs[slot] == 0) pairs[slot] = PairFits(options[first], options[second]) ? (sbyte)1 : (sbyte)-1;
return pairs[slot] > 0;
}
}
private sealed class PartialLayout(int nodeCount)
// A partial layout. Score counts each visible node once per covering miner; RawScore
// ignores burials and is therefore an upper bound for pruning.
private sealed class Layout(int nodeCount)
{
public readonly List<Candidate> Selected = [];
private readonly int[] _buried = new int[nodeCount], _uses = new int[nodeCount];
public int Score, RawScore, BuriedCount;
public int Gain(Candidate candidate)
public int Gain(Candidate candidate, out int coverage)
{
var gain = 0;
foreach (var index in candidate.Covered) if (_buried[index] == 0) gain++;
coverage = Coverage(candidate);
var gain = coverage;
foreach (var index in candidate.Buried) if (_buried[index] == 0) gain -= _uses[index];
return gain;
}
private int Coverage(Candidate candidate)
{
var coverage = 0;
foreach (var index in candidate.Covered) if (_buried[index] == 0) coverage++;
return coverage;
}
public bool CanAdd(Candidate candidate) => Coverage(candidate) >= MinimumCoverage && PreservesCoverage(candidate);
public bool FitsFrom(Candidate candidate, int start)
{
for (var i = start; i < Selected.Count; i++)
if (!PairFits(candidate, Selected[i])) return false;
return true;
}
// A placement must not invalidate an earlier miner, even if the total gain is positive.
// Every selected miner already keeps the minimum, so only newly buried used nodes matter.
public bool PreservesCoverage(Candidate candidate)
{
var affected = false;
foreach (var index in candidate.Buried)
if (_buried[index] == 0 && _uses[index] > 0) { affected = true; break; }
if (!affected) return true;
foreach (var other in Selected)
{
var visible = 0;
foreach (var index in other.Covered)
if (_buried[index] == 0 && Array.IndexOf(candidate.Buried, index) < 0 && ++visible >= MinimumCoverage) break;
if (visible < MinimumCoverage) return false;
}
return true;
}
public void Add(Candidate candidate)
{
RawScore += candidate.Covered.Length;
@@ -373,74 +497,14 @@ internal sealed class MinerPlacementSolver
foreach (var index in candidate.Buried)
if (--_buried[index] == 0) { Score += _uses[index]; BuriedCount--; }
}
public bool HasMinimumCoverage()
{
foreach (var candidate in Selected)
{
var visible = 0;
foreach (var index in candidate.Covered)
if (_buried[index] == 0 && ++visible >= MinimumCoverage) break;
if (visible < MinimumCoverage) return false;
}
return true;
}
}
private static void Consider(PartialLayout state, SearchResult result)
private static void Consider(Layout layout, SearchResult result)
{
if (!IsBetter(state.Score, state.BuriedCount, state.Selected.Count, result.Score, result.BuriedCount, result.Selected.Count)) return;
result.Selected = new List<Candidate>(state.Selected);
result.Score = state.Score;
result.BuriedCount = state.BuriedCount;
}
private static int CountBuried(List<Candidate> selected)
{
var buried = new HashSet<int>();
foreach (var candidate in selected) buried.UnionWith(candidate.Buried);
return buried.Count;
}
private static int Gain(Candidate candidate, bool[] buried, int[] uses, out int coverage)
{
coverage = 0;
foreach (var index in candidate.Covered) if (!buried[index]) coverage++;
var gain = coverage;
foreach (var index in candidate.Buried) if (!buried[index]) gain -= uses[index];
return gain;
}
private static void Add(Candidate candidate, List<Candidate> selected, bool[] buried, int[] uses, ref int score)
{
foreach (var index in candidate.Buried)
{
if (buried[index]) continue;
buried[index] = true;
score -= uses[index];
uses[index] = 0;
}
foreach (var index in candidate.Covered)
{
if (buried[index]) continue;
uses[index]++;
score++;
}
selected.Add(candidate);
}
private static bool PreservesCoverage(Candidate candidate, List<Candidate> selected, bool[] buried)
{
if (candidate.Buried.Length == 0) return true;
// A placement must not invalidate an earlier miner, even if the total gain is positive.
foreach (var other in selected)
{
var visible = 0;
foreach (var index in other.Covered)
if (!buried[index] && Array.IndexOf(candidate.Buried, index) < 0 && ++visible >= MinimumCoverage) break;
if (visible < MinimumCoverage) return false;
}
return true;
if (!IsBetter(layout.Score, layout.BuriedCount, layout.Selected.Count, result.Score, result.BuriedCount, result.Selected.Count)) return;
result.Selected = new List<Candidate>(layout.Selected);
result.Score = layout.Score;
result.BuriedCount = layout.BuriedCount;
}
public static bool Fits(Candidate candidate, List<Candidate> selected)
@@ -461,9 +525,9 @@ internal sealed class MinerPlacementSolver
private static bool Intersects(MinerPlacementGeometry.Box[] a, MinerPlacementGeometry.Box[] b)
{
foreach (var first in a)
foreach (var second in b)
if (MinerPlacementGeometry.Intersects(first, second)) return true;
for (var i = 0; i < a.Length; i++)
for (var j = 0; j < b.Length; j++)
if (MinerPlacementGeometry.Intersects(in a[i], in b[j])) return true;
return false;
}
}
+187 -134
View File
@@ -22,7 +22,6 @@ namespace UXAssist.Functions.Factory;
public static class QuickMinerBuild
{
private static Job _job;
private static IEnumerator _work;
private static readonly Stopwatch FrameTimer = new();
private static UIRealtimeTip _resultTip;
private static string _resultText;
@@ -42,7 +41,7 @@ public static class QuickMinerBuild
ReleaseResultTip(true);
if (IsRunning)
{
Cancel();
Stop();
UIRealtimeTip.Popup(I18NKeys.QuickMinerCancelled.Translate());
return;
}
@@ -57,7 +56,6 @@ public static class QuickMinerBuild
try
{
_job = new Job(player, planet);
_work = _job.Run();
UIRealtimeTip.Popup(I18NKeys.QuickMinerSearching.Translate());
}
catch (Exception exception)
@@ -72,7 +70,7 @@ public static class QuickMinerBuild
if (_job == null) return;
if (!_job.IsCurrent)
{
Cancel();
Stop();
return;
}
if (GameMain.isPaused) return;
@@ -81,13 +79,12 @@ public static class QuickMinerBuild
FrameTimer.Restart();
while (FrameTimer.ElapsedMilliseconds < 6)
{
if (_work.MoveNext())
if (!_job.Step())
{
if (_job.WaitingForWorkers) break;
continue;
Stop();
break;
}
Cancel();
break;
if (_job.WaitingForWorkers) break;
}
}
catch (Exception exception)
@@ -100,21 +97,21 @@ public static class QuickMinerBuild
{
UXAssist.Logger.LogError($"Quick miner placement failed: {exception}");
_job?.RecordFailure(exception);
Cancel();
Stop();
UIRealtimeTip.Popup(I18NKeys.QuickMinerFailed.Translate());
}
private static void Cancel()
// Completion, failure and cancellation all finish the job, which records its debug data.
private static void Stop()
{
_job?.Cancel();
(_work as IDisposable)?.Dispose();
_work = null;
var job = _job;
_job = null;
job?.Finish();
}
private static void OnGameEnd()
{
Cancel();
Stop();
ReleaseResultTip(true);
}
@@ -168,28 +165,36 @@ public static class QuickMinerBuild
private sealed class Job
{
// IsTargetVeinInRange accepts nodes within 7.75m horizontally and 2m vertically of a
// point 1.2m behind the miner, after scaling both positions to a 200m radius.
private const float MaxVeinReach = 9.25f;
private readonly Player _player;
private readonly PlanetData _planet;
private readonly PlanetFactory _factory;
private readonly PlanetPhysics _physics;
private readonly ItemProto _item;
private readonly List<Node> _nodes = [];
private readonly List<ColliderData> _obstacles = [];
private readonly List<ColliderData> _obstacles = [], _nearObstacles = [];
private readonly List<Vector3> _ejectors = [];
private readonly List<Candidate> _candidates = [];
private readonly List<int> _covered = [], _buried = [];
private readonly List<int> _covered = [], _buried = [], _reachable = [], _touching = [];
private readonly Box[] _buildBoxes, _obstacleBoxes;
private readonly ColliderData[] _nativeObstacles;
private readonly float _footprintRadius;
private readonly ColliderData _body;
private readonly float _footprintRadius, _halfDiagonal;
private readonly bool _capsule;
private readonly MinerPlacementDebug.Snapshot _debug = new();
private readonly List<MinerPlacementDebug.Phase> _phases = [];
private readonly List<MinerPlacementDebug.Placement> _placements = [];
private readonly Stopwatch _timer = Stopwatch.StartNew();
private readonly CancellationTokenSource _cancellation = new();
private readonly int _workers = MinerPlacementSolver.WorkerCount;
private IEnumerator _work;
private Task _search;
private long _searchMilliseconds;
private string _result;
private Vector3 _center, _right, _forward;
private Vector3 _center, _right, _forward, _probe;
private float _probeX = float.NaN, _probeZ = float.NaN;
private bool _probeRestricted;
private EVeinType _type;
private float _minX, _maxX, _minZ, _maxZ;
@@ -206,6 +211,7 @@ public static class QuickMinerBuild
_item = LDB.items.Select(ItemIds.MiningMachine);
var desc = _item.prefabDesc;
_buildBoxes = new Box[desc.buildColliders.Length];
_body = desc.buildColliders.OrderByDescending(c => c.ext.x * c.ext.y * c.ext.z).First();
var obstacles = new List<ColliderData>();
foreach (var collider in desc.colliders)
{
@@ -216,6 +222,9 @@ public static class QuickMinerBuild
}
_nativeObstacles = obstacles.ToArray();
_obstacleBoxes = new Box[_nativeObstacles.Length];
// Native clearance checks measure from the encompassing build collider.
_halfDiagonal = Mathf.Sqrt(desc.buildCollider.ext.x * desc.buildCollider.ext.x + desc.buildCollider.ext.z * desc.buildCollider.ext.z);
_capsule = planet.id == planet.galaxy.birthPlanetId && GameMain.history.SpaceCapsuleExist();
_debug.version = PluginInfo.PLUGIN_VERSION;
_debug.gameVersion = GameConfig.gameVersion.ToString();
_debug.startedUtc = DateTime.UtcNow.ToString("O");
@@ -233,30 +242,7 @@ public static class QuickMinerBuild
_debug.outcome = "cancelled";
}
public IEnumerator Run()
{
try
{
var work = RunCore();
try
{
while (true)
{
bool next;
try { next = work.MoveNext(); }
catch (Exception exception) { RecordFailure(exception); throw; }
if (!next) break;
yield return null;
}
}
finally { (work as IDisposable)?.Dispose(); }
}
finally
{
var location = WriteDebug();
if (_result != null) ShowResult(_result + "\n" + location);
}
}
public bool Step() => (_work ??= Run()).MoveNext();
public void RecordFailure(Exception exception)
{
@@ -264,7 +250,7 @@ public static class QuickMinerBuild
_debug.error = exception.ToString();
}
public void Cancel()
public void Finish()
{
_cancellation.Cancel();
if (_search == null || _search.IsCompleted)
@@ -277,27 +263,12 @@ public static class QuickMinerBuild
if (task.IsFaulted) _ = task.Exception;
_cancellation.Dispose();
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
(_work as IDisposable)?.Dispose();
var location = WriteDebug();
if (_result != null) ShowResult(_result + "\n" + location);
}
private IEnumerator Search(MinerPlacementSolver solver, int passes)
{
var timer = Stopwatch.StartNew();
if (_workers > 0)
{
_search = solver.SearchAsync(int.MaxValue, passes, _cancellation.Token, _workers);
while (!_search.IsCompleted) yield return null;
_search.GetAwaiter().GetResult();
_search = null;
}
else
{
var work = solver.Search(passes);
while (work.MoveNext()) yield return null;
}
_searchMilliseconds = timer.ElapsedMilliseconds;
}
private IEnumerator RunCore()
private IEnumerator Run()
{
if (!FindNodes())
{
@@ -321,36 +292,42 @@ public static class QuickMinerBuild
}
}
var solver = new MinerPlacementSolver(_candidates, _nodes.Count);
var search = Search(solver, 10);
while (search.MoveNext()) yield return null;
RecordPhase("coarse", solver, 10);
var packing = PackingNeighbors(solver.Best);
while (packing.MoveNext()) yield return null;
var refine = Refine(solver.Best, 0.35f, 3f);
while (refine.MoveNext()) yield return null;
search = Search(solver, 6);
while (search.MoveNext()) yield return null;
RecordPhase("refine-position", solver, 6);
packing = PackingNeighbors(solver.Best);
while (packing.MoveNext()) yield return null;
refine = Refine(solver.Best, 0.12f, 1f);
while (refine.MoveNext()) yield return null;
search = Search(solver, 4);
while (search.MoveNext()) yield return null;
RecordPhase("refine-angle", solver, 4);
if (IsCurrent)
{
_debug.outcome = "completed";
Commit(solver.Best);
}
var work = Search(solver, "coarse", 10);
while (work.MoveNext()) yield return null;
work = Expand(solver.Best, 0.35f, 3f);
while (work.MoveNext()) yield return null;
work = Search(solver, "refine-position", 6);
while (work.MoveNext()) yield return null;
work = Expand(solver.Best, 0.12f, 1f);
while (work.MoveNext()) yield return null;
work = Search(solver, "refine-angle", 4);
while (work.MoveNext()) yield return null;
_debug.outcome = "completed";
Commit(solver.Best);
}
private void RecordPhase(string name, MinerPlacementSolver solver, int passes) => _phases.Add(new MinerPlacementDebug.Phase
private IEnumerator Search(MinerPlacementSolver solver, string phase, int passes)
{
name = name, candidateCount = _candidates.Count, limit = int.MaxValue, passes = passes, score = solver.BestScore,
searchMilliseconds = _searchMilliseconds,
selected = solver.Best.Select(candidate => _candidates.IndexOf(candidate)).ToArray(), elapsedMilliseconds = _timer.ElapsedMilliseconds
});
var timer = Stopwatch.StartNew();
if (_workers > 0)
{
_search = solver.SearchAsync(passes, _cancellation.Token, _workers);
while (!_search.IsCompleted) yield return null;
_search.GetAwaiter().GetResult();
_search = null;
}
else
{
var work = solver.Search(passes);
while (work.MoveNext()) yield return null;
}
_phases.Add(new MinerPlacementDebug.Phase
{
name = phase, candidateCount = _candidates.Count, passes = passes, score = solver.BestScore,
searchMilliseconds = timer.ElapsedMilliseconds, elapsedMilliseconds = _timer.ElapsedMilliseconds,
selected = solver.Best.Select(candidate => _candidates.IndexOf(candidate)).ToArray()
});
}
private string WriteDebug()
{
@@ -442,6 +419,7 @@ public static class QuickMinerBuild
_obstacles.Add(collider);
}
}
FindEjectors(radius);
var reserved = ReservedNodes();
for (var i = 1; i < _factory.veinCursor; i++)
{
@@ -485,6 +463,29 @@ public static class QuickMinerBuild
return _nodes.Count > 0;
}
// Ejectors and their prebuilds near the search area; see Restricted.
private void FindEjectors(float radius)
{
if (_center.magnitude - _planet.realRadius + _item.prefabDesc.cullingHeight <= 4.9f) return;
var bound = radius + 7.2f + _halfDiagonal;
var factorySystem = _factory.factorySystem;
for (var i = 1; i < factorySystem.ejectorCursor; i++)
{
if (factorySystem.ejectorPool[i].id == i) Add(_factory.entityPool[factorySystem.ejectorPool[i].entityId].pos);
}
for (var i = 1; i < _factory.prebuildCursor; i++)
{
ref var prebuild = ref _factory.prebuildPool[i];
if (prebuild.id == i && LDB.items.Select(prebuild.protoId)?.prefabDesc.isEjector == true) Add(prebuild.pos);
}
return;
void Add(Vector3 position)
{
if ((position - _center).sqrMagnitude <= bound * bound) _ejectors.Add(position);
}
}
private HashSet<int> ReservedNodes()
{
var reserved = new HashSet<int>();
@@ -502,9 +503,19 @@ public static class QuickMinerBuild
private void RestoreTargetVeins()
{
var changed = false;
var bases = _factory.enemySystem.bases;
foreach (var node in _nodes)
{
if (!node.Target || node.Visible) continue;
// Like native reform, keep nodes buried within reach of Dark Fog ground bases.
var reformPoint = node.Position.normalized * _planet.realRadius;
var nearBase = false;
for (var i = 1; i < bases.cursor && !nearBase; i++)
{
var dfBase = bases.buffer[i];
nearBase = dfBase != null && dfBase.id == i && (reformPoint - (Vector3)_factory.enemyPool[dfBase.enemyId].pos).sqrMagnitude < 136.5625f;
}
if (nearBase) continue;
var surface = node.Position.normalized * (_planet.data.QueryModifiedHeight(node.Position) - 0.13f);
var collider = node.Collider;
collider.pos = surface + surface.normalized * 0.4f;
@@ -536,8 +547,30 @@ public static class QuickMinerBuild
if (changed) RefreshVeins(2);
}
private IEnumerator Refine(List<Candidate> seeds, float distance, float angle)
// Seed the next search around the current best layout: body-width neighbors whose feet
// can interleave, then a local grid of positions and rotations.
private IEnumerator Expand(List<Candidate> seeds, float distance, float angle)
{
foreach (var seed in seeds)
for (var turn = -15f; turn <= 15f; turn += 5f)
for (var side = -1; side <= 1; side++)
for (var clearance = 0.03f; clearance <= 0.14f; clearance += 0.05f)
for (var stagger = -2; stagger <= 2; stagger++)
{
if (side == 0 && clearance > 0.03f) continue;
// The legal interleaving gap is narrower than the coarse grid. Derive nearby
// rows from the actual body width instead of expanding a rectangle over the feet.
var rotation = seed.Rotation * Quaternion.AngleAxis(turn, Vector3.up);
var offset = rotation * _body.q * new Vector3(side * (_body.ext.x * 2f + clearance), 0f, stagger * 0.6f);
var x = seed.X + Vector3.Dot(offset, _right);
var z = seed.Z + Vector3.Dot(offset, _forward);
var frame = Maths.SphericalRotation(SurfacePoint(x, z), 0f);
var forward = rotation * Vector3.forward;
// Preserve the neighbor's surface heading across the planet's changing local frame.
var yaw = Mathf.Atan2(Vector3.Dot(forward, frame * Vector3.right), Vector3.Dot(forward, frame * Vector3.forward)) * Mathf.Rad2Deg;
TryCandidate(x, z, yaw);
yield return null;
}
foreach (var seed in seeds)
for (var x = -2; x <= 2; x++)
for (var z = -2; z <= 2; z++)
@@ -548,47 +581,24 @@ public static class QuickMinerBuild
}
}
private IEnumerator PackingNeighbors(List<Candidate> seeds)
{
var body = _item.prefabDesc.buildColliders.OrderByDescending(c => c.ext.x * c.ext.y * c.ext.z).First();
foreach (var seed in seeds)
for (var angle = -15f; angle <= 15f; angle += 5f)
for (var side = -1; side <= 1; side++)
for (var clearance = 0.03f; clearance <= 0.14f; clearance += 0.05f)
for (var stagger = -2; stagger <= 2; stagger++)
{
if (side == 0 && clearance > 0.03f) continue;
// The legal interleaving gap is narrower than the coarse grid. Derive nearby
// rows from the actual body width instead of expanding a rectangle over the feet.
var rotation = seed.Rotation * Quaternion.AngleAxis(angle, Vector3.up);
var bodyRotation = rotation * body.q;
var offset = bodyRotation * new Vector3(side * (body.ext.x * 2f + clearance), 0f, stagger * 0.6f);
var x = seed.X + Vector3.Dot(offset, _right);
var z = seed.Z + Vector3.Dot(offset, _forward);
var position = (_center + _right * x + _forward * z).normalized * (_planet.realRadius + 0.2f);
var frame = Maths.SphericalRotation(position, 0f);
var forward = rotation * Vector3.forward;
// Preserve the neighbor's surface heading across the planet's changing local frame.
var yaw = Mathf.Atan2(Vector3.Dot(forward, frame * Vector3.right), Vector3.Dot(forward, frame * Vector3.forward)) * Mathf.Rad2Deg;
TryCandidate(x, z, yaw);
yield return null;
}
}
private Vector3 SurfacePoint(float x, float z) => (_center + _right * x + _forward * z).normalized * (_planet.realRadius + 0.2f);
private void TryCandidate(float x, float z, float yaw)
{
_debug.rejections.attempted++;
var pos = (_center + _right * x + _forward * z).normalized * (_planet.realRadius + 0.2f);
if (x != _probeX || z != _probeZ) Probe(x, z);
var pos = _probe;
if (!FactoryPatch.RemoveBuildRangeLimitEnabled.Value &&
(pos - _player.position).sqrMagnitude > _player.mecha.buildArea * _player.mecha.buildArea)
{ _debug.rejections.range++; return; }
if (_probeRestricted) { _debug.rejections.clearance++; return; }
var rotation = Maths.SphericalRotation(pos, yaw);
var pose = new Pose(pos, rotation);
_covered.Clear();
for (var i = 0; i < _nodes.Count; i++)
foreach (var i in _reachable)
{
var node = _nodes[i];
if (!node.Visible || node.Type == EVeinType.Oil || !MinerComponent.IsTargetVeinInRange(node.Position, pose, _item.prefabDesc)) continue;
if (!MinerComponent.IsTargetVeinInRange(node.Position, pose, _item.prefabDesc)) continue;
if (node.Type != _type) { _debug.rejections.mixedType++; return; }
_covered.Add(i);
}
@@ -596,16 +606,16 @@ public static class QuickMinerBuild
for (var i = 0; i < _buildBoxes.Length; i++)
_buildBoxes[i] = new Box(_item.prefabDesc.buildColliders[i].BindToObject(0, 0, EObjectType.None, pos, rotation));
_buried.Clear();
for (var i = 0; i < _nodes.Count; i++)
foreach (var i in _touching)
{
var node = _nodes[i];
if (!node.Visible || !Hits(node.Collider)) continue;
if (!Hits(node.Collider)) continue;
if (!node.CanBury) { _debug.rejections.veinCollision++; return; }
_buried.Add(i);
}
foreach (var index in _buried) _covered.Remove(index);
if (_covered.Count < MinerPlacementSolver.MinimumCoverage) { _debug.rejections.noCoverage++; return; }
foreach (var obstacle in _obstacles)
foreach (var obstacle in _nearObstacles)
if (Hits(obstacle)) { _debug.rejections.buildingCollision++; return; }
if (!HasGround(pos, rotation)) { _debug.rejections.ground++; return; }
for (var i = 0; i < _nativeObstacles.Length; i++)
@@ -618,6 +628,49 @@ public static class QuickMinerBuild
});
}
// Candidate positions repeat across yaw angles. Keep only the nodes and obstacles that can
// interact with a miner here; the rest fail the native range and collision tests anyway.
private void Probe(float x, float z)
{
_probeX = x;
_probeZ = z;
_probe = SurfacePoint(x, z);
_probeRestricted = Restricted(_probe);
var rangePoint = _probe.normalized * 200f;
_reachable.Clear();
_touching.Clear();
_nearObstacles.Clear();
for (var i = 0; i < _nodes.Count; i++)
{
var node = _nodes[i];
if (!node.Visible) continue;
if (node.Type != EVeinType.Oil && (node.Position.normalized * 200f - rangePoint).sqrMagnitude <= MaxVeinReach * MaxVeinReach)
_reachable.Add(i);
if (Near(node.Collider)) _touching.Add(i);
}
foreach (var obstacle in _obstacles)
if (Near(obstacle)) _nearObstacles.Add(obstacle);
}
// Native placement keeps buildings clear of the birth planet's landing capsule and, when
// they are tall enough to obstruct launches, of EM Rail Ejectors.
private bool Restricted(Vector3 position)
{
if (_capsule && (position - _planet.birthPoint).magnitude - _halfDiagonal < 3.7f) return true;
var clearance = 7.2f + _halfDiagonal;
foreach (var ejector in _ejectors)
if ((ejector - position).sqrMagnitude < clearance * clearance) return true;
return false;
}
// Every build box lies within the footprint radius of the probe, so a farther collider
// also fails each box's bounding-sphere test in Hits.
private bool Near(ColliderData collider)
{
var bound = _footprintRadius + collider.ext.magnitude + collider.radius + 0.01f;
return (collider.pos - _probe).sqrMagnitude <= bound * bound;
}
private bool Hits(ColliderData collider)
{
foreach (var box in _buildBoxes)
@@ -649,6 +702,12 @@ public static class QuickMinerBuild
private void Commit(List<Candidate> layout)
{
if (layout.Count == 0)
{
_debug.outcome = "no-placement";
_result = I18NKeys.QuickMinerNoPlacement.Translate();
return;
}
if (!NodesUnchanged(layout))
{
_debug.outcome = "veins-changed";
@@ -658,12 +717,6 @@ public static class QuickMinerBuild
var placed = new List<(Candidate Candidate, int Prebuild, MinerPlacementDebug.Placement Debug)>();
var plannedBurial = layout.SelectMany(candidate => candidate.Buried).Select(index => _nodes[index].Id).ToHashSet();
var hidden = new Dictionary<int, Vector3>();
if (layout.Count == 0)
{
_debug.outcome = "no-placement";
_result = I18NKeys.QuickMinerNoPlacement.Translate();
return;
}
var coverage = 0;
var buriedCount = 0;
var validator = new BuildTool_Click();
@@ -677,9 +730,8 @@ public static class QuickMinerBuild
validator.tmpPackage = new StorageComponent(1);
var preview = new BuildPreview();
validator.buildPreviews.Add(preview);
for (var i = 0; i < layout.Count; i++)
foreach (var candidate in layout)
{
var candidate = layout[i];
var debug = new MinerPlacementDebug.Placement
{
candidate = _candidates.IndexOf(candidate), outcome = "pending", nativeCondition = "not-checked", nativeVeins = [], plannedVeins = [], finalVeins = []
@@ -694,7 +746,8 @@ public static class QuickMinerBuild
hidden.Add(node.Id, vein.pos);
SetVeinPosition(node.Id, vein.pos.normalized * (_planet.realRadius - 50f));
}
RefreshVeins(0);
// Validation needs current Unity colliders; GPU buffers are synced once at the end.
_physics.RefreshColliders();
if (!Validate(validator, preview, candidate, plannedBurial, debug)) continue;
var itemId = ItemIds.MiningMachine;
var count = 1;
@@ -773,10 +826,10 @@ public static class QuickMinerBuild
return true;
}
// CheckBuildConditions repeats the search's land-point tests, so ground needs no separate check.
private bool Validate(BuildTool_Click validator, BuildPreview preview, Candidate candidate, HashSet<int> plannedBurial, MinerPlacementDebug.Placement debug)
{
debug.outcome = "native-rejected";
if (!HasGround(candidate.Position, candidate.Rotation)) { debug.outcome = "ground-changed"; return false; }
preview.ResetAll();
preview.item = _item;
preview.desc = _item.prefabDesc;