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

+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;
}
}