mirror of
https://github.com/soarqin/DSP_Mods.git
synced 2026-11-19 17:05:20 +08:00
Restrict layout coverage and miner vein lists to the selected group so nearby deposits of the same resource cannot attract placement. Preserve neighboring vein collision checks and enforce the three-node minimum after planned burials. Tag debug snapshots with target-group semantics, validate group membership during replay, and synchronize the English and Chinese documentation.
943 lines
45 KiB
C#
943 lines
45 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using BepInEx;
|
|
using BepInEx.Configuration;
|
|
using UnityEngine;
|
|
using UXAssist.Common;
|
|
using UXAssist.Common.GameConstants;
|
|
using UXAssist.Common.ModFeatures;
|
|
using UXAssist.Patches.Factory;
|
|
using Candidate = UXAssist.Functions.Factory.MinerPlacementSolver.Candidate;
|
|
using Box = UXAssist.Functions.Factory.MinerPlacementGeometry.Box;
|
|
using GameLogicProc = UXAssist.Common.GameLogic;
|
|
|
|
namespace UXAssist.Functions.Factory;
|
|
|
|
[ModFeature("QuickMinerBuild")]
|
|
public static class QuickMinerBuild
|
|
{
|
|
public static ConfigEntry<bool> AllowVeinReform;
|
|
|
|
private static Job _job;
|
|
private static readonly Stopwatch FrameTimer = new();
|
|
private static UIRealtimeTip _resultTip;
|
|
private static string _resultText;
|
|
private static float _resultTipUntil, _resultTipSpeed;
|
|
public static bool IsRunning => _job != null;
|
|
|
|
public static void Init() => GameLogicProc.OnGameEnd += OnGameEnd;
|
|
|
|
public static void Uninit()
|
|
{
|
|
OnGameEnd();
|
|
GameLogicProc.OnGameEnd -= OnGameEnd;
|
|
}
|
|
|
|
public static void Toggle()
|
|
{
|
|
ReleaseResultTip(true);
|
|
if (IsRunning)
|
|
{
|
|
Stop();
|
|
UIRealtimeTip.Popup(I18NKeys.QuickMinerCancelled.Translate());
|
|
return;
|
|
}
|
|
var player = GameMain.mainPlayer;
|
|
var planet = GameMain.localPlanet;
|
|
if (!GameMain.isRunning || DSPGame.IsMenuDemo || player?.controller?.actionBuild == null ||
|
|
planet?.factory == null || !planet.factoryLoaded || planet.physics == null || planet.type == EPlanetType.Gas)
|
|
{
|
|
UIRealtimeTip.Popup(I18NKeys.QuickMinerNeedPlanet.Translate());
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
_job = new Job(player, planet, AllowVeinReform.Value);
|
|
UIRealtimeTip.Popup(I18NKeys.QuickMinerSearching.Translate());
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Fail(exception);
|
|
}
|
|
}
|
|
|
|
public static void OnUpdate()
|
|
{
|
|
UpdateResultTip();
|
|
if (_job == null) return;
|
|
if (!_job.IsCurrent)
|
|
{
|
|
Stop();
|
|
return;
|
|
}
|
|
if (GameMain.isPaused) return;
|
|
try
|
|
{
|
|
FrameTimer.Restart();
|
|
while (FrameTimer.ElapsedMilliseconds < 6)
|
|
{
|
|
if (!_job.Step())
|
|
{
|
|
Stop();
|
|
break;
|
|
}
|
|
if (_job.WaitingForWorkers) break;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Fail(exception);
|
|
}
|
|
}
|
|
|
|
private static void Fail(Exception exception)
|
|
{
|
|
UXAssist.Logger.LogError($"Quick miner placement failed: {exception}");
|
|
_job?.RecordFailure(exception);
|
|
Stop();
|
|
UIRealtimeTip.Popup(I18NKeys.QuickMinerFailed.Translate());
|
|
}
|
|
|
|
// Completion, failure and cancellation all finish the job, which records its debug data.
|
|
private static void Stop()
|
|
{
|
|
var job = _job;
|
|
_job = null;
|
|
job?.Finish();
|
|
}
|
|
|
|
private static void OnGameEnd()
|
|
{
|
|
Stop();
|
|
ReleaseResultTip(true);
|
|
}
|
|
|
|
private static void ShowResult(string message)
|
|
{
|
|
UXAssist.Logger.LogInfo($"Quick miner result: {message.Replace("\n", " | ")}");
|
|
UIRealtimeTip.Popup(message);
|
|
foreach (var tip in UIRoot.instance.uiGame.generalTips.realtimeTips)
|
|
{
|
|
if (!tip.gameObject.activeSelf || tip.textComp.text != message) continue;
|
|
_resultTip = tip;
|
|
_resultText = message;
|
|
_resultTipSpeed = tip.upSpeed;
|
|
_resultTipUntil = Time.unscaledTime + 8f;
|
|
tip.upSpeed = 0f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void UpdateResultTip()
|
|
{
|
|
if (!_resultTip) return;
|
|
if (!_resultTip.gameObject.activeSelf || _resultTip.textComp.text != _resultText || Time.unscaledTime >= _resultTipUntil)
|
|
{
|
|
ReleaseResultTip(false);
|
|
return;
|
|
}
|
|
// Native Update derives scale and alpha from lifeTime; values above 1 hide the tip.
|
|
_resultTip.lifeTime = 0.8f;
|
|
}
|
|
|
|
private static void ReleaseResultTip(bool hide)
|
|
{
|
|
if (_resultTip && _resultTip.textComp.text == _resultText)
|
|
{
|
|
_resultTip.upSpeed = _resultTipSpeed;
|
|
if (hide) _resultTip.gameObject.SetActive(false);
|
|
}
|
|
_resultTip = null;
|
|
_resultText = null;
|
|
}
|
|
|
|
private sealed class Node
|
|
{
|
|
public int Id;
|
|
public Vector3 Position, OriginalPosition;
|
|
public ColliderData Collider;
|
|
public bool Target, Visible, CanBury;
|
|
public EVeinType Type;
|
|
}
|
|
|
|
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 = [], _nearObstacles = [];
|
|
private readonly List<Vector3> _ejectors = [];
|
|
private readonly List<Candidate> _candidates = [];
|
|
private readonly List<int> _covered = [], _reachable = [], _touching = [];
|
|
private readonly List<int> _buried;
|
|
private readonly Box[] _buildBoxes, _obstacleBoxes;
|
|
private readonly ColliderData[] _nativeObstacles;
|
|
private readonly ColliderData _body;
|
|
private readonly float _footprintRadius, _halfDiagonal;
|
|
private readonly bool _capsule, _allowVeinReform;
|
|
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 string _result;
|
|
private Vector3 _center, _right, _forward, _probe;
|
|
private float _probeX = float.NaN, _probeZ = float.NaN;
|
|
private bool _probeRestricted;
|
|
private EVeinType _type;
|
|
private int _group;
|
|
private float _minX, _maxX, _minZ, _maxZ;
|
|
|
|
public bool IsCurrent => GameMain.isRunning && GameMain.mainPlayer == _player &&
|
|
GameMain.localPlanet == _planet && _planet.factory == _factory && _planet.physics == _physics && _planet.factoryLoaded;
|
|
public bool WaitingForWorkers => _search != null && !_search.IsCompleted;
|
|
|
|
public Job(Player player, PlanetData planet, bool allowVeinReform)
|
|
{
|
|
_player = player;
|
|
_planet = planet;
|
|
_allowVeinReform = allowVeinReform;
|
|
_buried = allowVeinReform ? [] : null;
|
|
_factory = planet.factory;
|
|
_physics = planet.physics;
|
|
_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)
|
|
{
|
|
if (!collider.isForBuild) continue;
|
|
if (collider.shape != EColliderShape.Box) throw new NotSupportedException("Mining Machine build collider is not a box.");
|
|
obstacles.Add(collider);
|
|
_footprintRadius = Mathf.Max(_footprintRadius, collider.pos.magnitude + collider.ext.magnitude);
|
|
}
|
|
_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");
|
|
_debug.logicalProcessors = Environment.ProcessorCount;
|
|
_debug.workerCount = _workers;
|
|
_debug.planetId = planet.id;
|
|
_debug.planetRadius = planet.realRadius;
|
|
_debug.initialStock = player.package.GetItemCount(ItemIds.MiningMachine) +
|
|
(player.inhandItemId == ItemIds.MiningMachine ? player.inhandItemCount : 0);
|
|
_debug.playerPosition = MinerPlacementDebug.Vector(player.position);
|
|
_debug.buildRange = player.mecha.buildArea;
|
|
_debug.unlimitedRange = FactoryPatch.RemoveBuildRangeLimitEnabled.Value;
|
|
_debug.allowVeinReform = allowVeinReform;
|
|
_debug.buildColliders = desc.buildColliders.Select(MinerPlacementDebug.Collider.Capture).ToArray();
|
|
_debug.minerColliders = _nativeObstacles.Select(MinerPlacementDebug.Collider.Capture).ToArray();
|
|
_debug.outcome = "cancelled";
|
|
}
|
|
|
|
public bool Step() => (_work ??= Run()).MoveNext();
|
|
|
|
public void RecordFailure(Exception exception)
|
|
{
|
|
_debug.outcome = "failed";
|
|
_debug.error = exception.ToString();
|
|
}
|
|
|
|
public void Finish()
|
|
{
|
|
_cancellation.Cancel();
|
|
if (_search == null || _search.IsCompleted)
|
|
{
|
|
if (_search?.IsFaulted == true) _ = _search.Exception;
|
|
_cancellation.Dispose();
|
|
}
|
|
else _search.ContinueWith(task =>
|
|
{
|
|
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 Run()
|
|
{
|
|
if (!FindNodes())
|
|
{
|
|
_debug.outcome = "no-veins";
|
|
_result = I18NKeys.QuickMinerNoVeins.Translate();
|
|
yield break;
|
|
}
|
|
if (_allowVeinReform) RestoreTargetVeins();
|
|
var reach = 9.5f * _planet.realRadius / 200f;
|
|
var width = _maxX - _minX + reach * 2;
|
|
var depth = _maxZ - _minZ + reach * 2;
|
|
// Bound the coarse search by 4,000 surface positions, then refine promising layouts.
|
|
var step = Mathf.Max(0.8f, Mathf.Sqrt(width * depth / 4000f));
|
|
for (var x = _minX - reach; x <= _maxX + reach; x += step)
|
|
for (var z = _minZ - reach; z <= _maxZ + reach; z += step)
|
|
{
|
|
for (var yaw = 0f; yaw < 360f; yaw += 15f)
|
|
{
|
|
TryCandidate(x, z, yaw);
|
|
yield return null;
|
|
}
|
|
}
|
|
var solver = new MinerPlacementSolver(_candidates, _nodes.Count, _allowVeinReform);
|
|
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 IEnumerator Search(MinerPlacementSolver solver, string phase, int passes)
|
|
{
|
|
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()
|
|
{
|
|
try
|
|
{
|
|
_debug.elapsedMilliseconds = _timer.ElapsedMilliseconds;
|
|
_debug.veinType = (int)_type;
|
|
_debug.center = MinerPlacementDebug.Vector(_center);
|
|
_debug.right = MinerPlacementDebug.Vector(_right);
|
|
_debug.forward = MinerPlacementDebug.Vector(_forward);
|
|
_debug.nodes = _nodes.Select(node => new MinerPlacementDebug.Node
|
|
{
|
|
id = node.Id, type = (int)node.Type, target = node.Target, visible = node.Visible, canBury = node.CanBury,
|
|
originalPosition = MinerPlacementDebug.Vector(node.OriginalPosition), position = MinerPlacementDebug.Vector(node.Position),
|
|
collider = MinerPlacementDebug.Collider.Capture(node.Collider)
|
|
}).ToArray();
|
|
_debug.obstacles = _obstacles.Select(MinerPlacementDebug.Collider.Capture).ToArray();
|
|
_debug.candidates = _candidates.Select(MinerPlacementDebug.CandidateData.Capture).ToArray();
|
|
_debug.phases = _phases.ToArray();
|
|
_debug.placements = _placements.ToArray();
|
|
const string relative = "debug/UXAssist/QuickMiner";
|
|
var directory = Path.Combine(Paths.BepInExRootPath, relative);
|
|
Directory.CreateDirectory(directory);
|
|
var file = Path.Combine(directory, $"{DateTime.UtcNow:yyyyMMdd-HHmmss-fff}-planet-{_debug.planetId}-{Guid.NewGuid():N}.json");
|
|
MinerPlacementDebug.Write(file, _debug);
|
|
UXAssist.Logger.LogInfo($"Quick miner debug: {file}");
|
|
return string.Format(I18NKeys.QuickMinerDebugSaved.Translate(), "BepInEx/" + relative);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
UXAssist.Logger.LogWarning($"Quick miner debug export failed: {exception}");
|
|
return I18NKeys.QuickMinerDebugFailed.Translate();
|
|
}
|
|
}
|
|
|
|
private bool FindNodes()
|
|
{
|
|
var nearest = float.PositiveInfinity;
|
|
var group = 0;
|
|
for (var i = 1; i < _factory.veinCursor; i++)
|
|
{
|
|
ref var vein = ref _factory.veinPool[i];
|
|
if (vein.id != i || vein.amount <= 0 || vein.type is EVeinType.None or EVeinType.Oil) continue;
|
|
if (!_allowVeinReform && vein.pos.magnitude < _planet.realRadius - 40f) continue;
|
|
var distance = (vein.pos.normalized * _planet.realRadius - _player.position).sqrMagnitude;
|
|
if (distance >= nearest) continue;
|
|
nearest = distance;
|
|
group = vein.groupIndex;
|
|
_type = vein.type;
|
|
}
|
|
if (group == 0) return false;
|
|
_group = group;
|
|
_debug.veinGroup = group;
|
|
var count = 0;
|
|
for (var i = 1; i < _factory.veinCursor; i++)
|
|
{
|
|
ref var vein = ref _factory.veinPool[i];
|
|
if (vein.id != i || vein.amount <= 0 || vein.groupIndex != group) continue;
|
|
_center += vein.pos.normalized;
|
|
count++;
|
|
}
|
|
if (count == 0) return false;
|
|
_center = _center.normalized * (_planet.realRadius + 0.2f);
|
|
var rotation = Maths.SphericalRotation(_center, 0f);
|
|
_right = rotation * Vector3.right;
|
|
_forward = rotation * Vector3.forward;
|
|
var radius = 0f;
|
|
for (var i = 1; i < _factory.veinCursor; i++)
|
|
{
|
|
ref var vein = ref _factory.veinPool[i];
|
|
if (vein.id != i || vein.amount <= 0 || vein.groupIndex != group) continue;
|
|
var delta = vein.pos.normalized * (_planet.realRadius + 0.2f) - _center;
|
|
var x = Vector3.Dot(delta, _right);
|
|
var z = Vector3.Dot(delta, _forward);
|
|
_minX = Mathf.Min(_minX, x);
|
|
_maxX = Mathf.Max(_maxX, x);
|
|
_minZ = Mathf.Min(_minZ, z);
|
|
_maxZ = Mathf.Max(_maxZ, z);
|
|
radius = Mathf.Max(radius, delta.magnitude);
|
|
}
|
|
radius += 20f * _planet.realRadius / 200f + _footprintRadius;
|
|
// Read the native data, including inactive colliders outside the camera/player area.
|
|
// Physics queries alone can miss those colliders when the config window is open.
|
|
foreach (var chunk in _physics.colChunks)
|
|
{
|
|
for (var i = 1; i < chunk.cursor; i++)
|
|
{
|
|
var collider = chunk.colliderPool[i];
|
|
var bound = radius + collider.ext.magnitude + collider.radius;
|
|
if (collider.idType != 0 && collider.isForBuild && (collider.pos - _center).sqrMagnitude <= bound * bound)
|
|
_obstacles.Add(collider);
|
|
}
|
|
}
|
|
FindEjectors(radius);
|
|
var reserved = _allowVeinReform ? ReservedNodes() : null;
|
|
for (var i = 1; i < _factory.veinCursor; i++)
|
|
{
|
|
ref var vein = ref _factory.veinPool[i];
|
|
if (vein.id != i || vein.amount <= 0 || vein.colliderId <= 0) continue;
|
|
var surface = vein.pos.normalized * (_planet.realRadius + 0.2f);
|
|
if ((surface - _center).sqrMagnitude > radius * radius) continue;
|
|
_nodes.Add(new Node
|
|
{
|
|
Id = i, Target = vein.groupIndex == group, Type = vein.type,
|
|
Position = vein.pos, OriginalPosition = vein.pos, Collider = _physics.GetColliderData(vein.colliderId),
|
|
Visible = vein.pos.magnitude >= _planet.realRadius - 40f,
|
|
CanBury = _allowVeinReform && vein.groupIndex == group && vein.minerCount == 0 && !reserved.Contains(i)
|
|
});
|
|
}
|
|
var existing = new List<MinerPlacementDebug.ExistingMiner>();
|
|
for (var i = 1; i < _factory.entityCursor; i++)
|
|
{
|
|
ref var entity = ref _factory.entityPool[i];
|
|
if (entity.id != i || entity.protoId != ItemIds.MiningMachine || entity.minerId <= 0 ||
|
|
(entity.pos - _center).sqrMagnitude > radius * radius) continue;
|
|
ref var miner = ref _factory.factorySystem.minerPool[entity.minerId];
|
|
existing.Add(new MinerPlacementDebug.ExistingMiner
|
|
{
|
|
entityId = i, minerId = entity.minerId, position = MinerPlacementDebug.Vector(entity.pos),
|
|
rotation = MinerPlacementDebug.Rotation(entity.rot), veins = miner.veins?.Take(miner.veinCount).ToArray() ?? []
|
|
});
|
|
}
|
|
for (var i = 1; i < _factory.prebuildCursor; i++)
|
|
{
|
|
ref var prebuild = ref _factory.prebuildPool[i];
|
|
if (prebuild.id != i || prebuild.protoId != ItemIds.MiningMachine ||
|
|
(prebuild.pos - _center).sqrMagnitude > radius * radius) continue;
|
|
existing.Add(new MinerPlacementDebug.ExistingMiner
|
|
{
|
|
entityId = i, prebuild = true, position = MinerPlacementDebug.Vector(prebuild.pos),
|
|
rotation = MinerPlacementDebug.Rotation(prebuild.rot), veins = prebuild.parameters?.Take(prebuild.paramCount).ToArray() ?? []
|
|
});
|
|
}
|
|
_debug.existingMiners = existing.ToArray();
|
|
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>();
|
|
for (var i = 1; i < _factory.prebuildCursor; i++)
|
|
{
|
|
ref var prebuild = ref _factory.prebuildPool[i];
|
|
if (prebuild.id != i || prebuild.parameters == null) continue;
|
|
var desc = LDB.models.Select(prebuild.modelIndex)?.prefabDesc;
|
|
if (desc == null || !desc.veinMiner) continue;
|
|
for (var j = desc.isVeinCollector ? 2048 : 0; j < prebuild.paramCount; j++) reserved.Add(prebuild.parameters[j]);
|
|
}
|
|
return reserved;
|
|
}
|
|
|
|
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;
|
|
var obstructed = false;
|
|
foreach (var obstacle in _obstacles)
|
|
{
|
|
// Building triggers are normally boxes. For unusual spherical/capsule
|
|
// triggers, conservatively keep the node buried inside their bounds.
|
|
var bound = obstacle;
|
|
if (bound.shape != EColliderShape.Box)
|
|
{
|
|
bound.idType = (int)EColliderShape.Box << 24;
|
|
bound.q = Quaternion.identity;
|
|
bound.ext = new Vector3(Mathf.Abs(obstacle.ext.x), Mathf.Abs(obstacle.ext.y), Mathf.Abs(obstacle.ext.z)) + Vector3.one * obstacle.radius;
|
|
}
|
|
if (MinerPlacementGeometry.Intersects(new Box(bound), collider))
|
|
{
|
|
obstructed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (obstructed) continue;
|
|
SetVeinPosition(node.Id, surface);
|
|
node.Position = surface;
|
|
node.Collider = _physics.GetColliderData(_factory.veinPool[node.Id].colliderId);
|
|
node.Visible = true;
|
|
changed = true;
|
|
}
|
|
if (changed) RefreshVeins(2);
|
|
}
|
|
|
|
// 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++)
|
|
for (var yaw = -2; yaw <= 2; yaw++)
|
|
{
|
|
TryCandidate(seed.X + x * distance, seed.Z + z * distance, seed.Yaw + yaw * angle);
|
|
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++;
|
|
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();
|
|
foreach (var i in _reachable)
|
|
{
|
|
var node = _nodes[i];
|
|
if (!MinerComponent.IsTargetVeinInRange(node.Position, pose, _item.prefabDesc)) continue;
|
|
if (node.Type != _type) { _debug.rejections.mixedType++; return; }
|
|
if (node.Target) _covered.Add(i);
|
|
}
|
|
if (_covered.Count < MinerPlacementSolver.MinimumCoverage) { _debug.rejections.noCoverage++; return; }
|
|
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();
|
|
foreach (var i in _touching)
|
|
{
|
|
var node = _nodes[i];
|
|
if (!Hits(node.Collider)) continue;
|
|
if (!node.CanBury) { _debug.rejections.veinCollision++; return; }
|
|
_buried.Add(i);
|
|
}
|
|
if (_allowVeinReform)
|
|
{
|
|
foreach (var index in _buried) _covered.Remove(index);
|
|
if (_covered.Count < MinerPlacementSolver.MinimumCoverage) { _debug.rejections.noCoverage++; return; }
|
|
}
|
|
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++)
|
|
_obstacleBoxes[i] = new Box(_nativeObstacles[i].BindToObject(0, 0, EObjectType.None, pos, rotation));
|
|
_candidates.Add(new Candidate
|
|
{
|
|
X = x, Z = z, Yaw = yaw, Position = pos, Rotation = rotation, Radius = _footprintRadius,
|
|
Covered = _covered.ToArray(), Buried = _buried?.ToArray() ?? [],
|
|
BuildBoxes = (Box[])_buildBoxes.Clone(), ObstacleBoxes = (Box[])_obstacleBoxes.Clone()
|
|
});
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
var radius = box.Extents.magnitude + collider.ext.magnitude + collider.radius;
|
|
if ((box.Center - collider.pos).sqrMagnitude <= radius * radius && MinerPlacementGeometry.Intersects(box, collider)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool HasGround(Vector3 position, Quaternion rotation)
|
|
{
|
|
// Match the ordinary miner's native land-point tests, including water clearance.
|
|
var desc = _item.prefabDesc;
|
|
foreach (var point in desc.landPoints)
|
|
{
|
|
var origin = position + rotation * new Vector3(point.x, 0f, point.z);
|
|
var up = origin.normalized;
|
|
origin += up * 3f;
|
|
if (!Physics.Raycast(origin, -up, out var ground, 18f,
|
|
(1 << (int)Layer.Terrain) | (1 << (int)Layer.Platform), QueryTriggerInteraction.Collide) ||
|
|
ground.point.magnitude - _planet.realRadius < -0.3f - desc.landOffset) return false;
|
|
var waterDistance = Physics.Raycast(origin, -up, out var water, 20f, 1 << (int)Layer.Water, QueryTriggerInteraction.Collide)
|
|
? water.distance : 1000f;
|
|
if (ground.distance - waterDistance > 0.27f + desc.landOffset) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
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";
|
|
_result = I18NKeys.QuickMinerVeinsChanged.Translate();
|
|
return;
|
|
}
|
|
var placed = new List<(Candidate Candidate, int Prebuild, MinerPlacementDebug.Placement Debug)>();
|
|
var plannedBurial = _allowVeinReform
|
|
? layout.SelectMany(candidate => candidate.Buried).Select(index => _nodes[index].Id).ToHashSet() : null;
|
|
var hidden = _allowVeinReform ? new Dictionary<int, Vector3>() : null;
|
|
var coverage = 0;
|
|
var buriedCount = 0;
|
|
var validator = new BuildTool_Click();
|
|
try
|
|
{
|
|
validator._Init(GameMain.data);
|
|
validator.planet = _planet;
|
|
validator.factory = _factory;
|
|
validator.handItem = _item;
|
|
validator.handPrefabDesc = _item.prefabDesc;
|
|
validator.tmpPackage = new StorageComponent(1);
|
|
var preview = new BuildPreview();
|
|
validator.buildPreviews.Add(preview);
|
|
foreach (var candidate in layout)
|
|
{
|
|
var debug = new MinerPlacementDebug.Placement
|
|
{
|
|
candidate = _candidates.IndexOf(candidate), outcome = "pending", nativeCondition = "not-checked", nativeVeins = [], plannedVeins = [], finalVeins = []
|
|
};
|
|
_placements.Add(debug);
|
|
// No yield between burial, native validation, item consumption, and creation.
|
|
if (_allowVeinReform)
|
|
{
|
|
foreach (var index in candidate.Buried)
|
|
{
|
|
var node = _nodes[index];
|
|
ref var vein = ref _factory.veinPool[node.Id];
|
|
if (vein.id != node.Id || hidden.ContainsKey(node.Id)) continue;
|
|
hidden.Add(node.Id, vein.pos);
|
|
SetVeinPosition(node.Id, vein.pos.normalized * (_planet.realRadius - 50f));
|
|
}
|
|
}
|
|
// 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;
|
|
if (_player.inhandItemId == itemId && _player.inhandItemCount > 0) _player.UseHandItems(1, out _);
|
|
else _player.package.TakeTailItems(ref itemId, ref count, out _);
|
|
// Match native blueprint placement: missing items leave unfunded prebuilds.
|
|
var prebuild = new PrebuildData
|
|
{
|
|
protoId = (short)_item.ID, modelIndex = (short)_item.prefabDesc.modelIndex,
|
|
pos = candidate.Position, pos2 = candidate.Position, rot = candidate.Rotation, rot2 = candidate.Rotation,
|
|
itemRequired = count == 1 ? 0 : 1,
|
|
filterId = _factory.veinPool[_nodes[candidate.Covered[0]].Id].productId
|
|
};
|
|
prebuild.InitParametersArray(debug.plannedVeins.Length);
|
|
Array.Copy(debug.plannedVeins, prebuild.parameters, debug.plannedVeins.Length);
|
|
var id = _factory.AddPrebuildDataWithComponents(prebuild);
|
|
debug.prebuildId = id;
|
|
debug.itemRequired = prebuild.itemRequired;
|
|
debug.outcome = id > 0 ? "placed" : "prebuild-failed";
|
|
if (id == 0 && count == 1) _player.TryAddItemToPackage(ItemIds.MiningMachine, 1, 0, true);
|
|
if (id > 0) placed.Add((candidate, id, debug));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
validator._Free();
|
|
// A failed/shortened layout must not leave nodes buried for unplaced miners.
|
|
if (_allowVeinReform)
|
|
{
|
|
var needed = new HashSet<int>();
|
|
foreach (var entry in placed)
|
|
foreach (var index in entry.Candidate.Buried) needed.Add(_nodes[index].Id);
|
|
foreach (var entry in hidden)
|
|
if (!needed.Contains(entry.Key)) SetVeinPosition(entry.Key, entry.Value);
|
|
buriedCount = needed.Count;
|
|
}
|
|
foreach (var entry in placed)
|
|
{
|
|
var ids = new List<int>();
|
|
var pose = new Pose(entry.Candidate.Position, entry.Candidate.Rotation);
|
|
foreach (var node in _nodes)
|
|
{
|
|
ref var vein = ref _factory.veinPool[node.Id];
|
|
if (node.Target && vein.id == node.Id && vein.amount > 0 && vein.type == _type && vein.pos.magnitude >= _planet.realRadius - 40f &&
|
|
MinerComponent.IsTargetVeinInRange(vein.pos, pose, _item.prefabDesc)) ids.Add(node.Id);
|
|
}
|
|
ref var prebuild = ref _factory.prebuildPool[entry.Prebuild];
|
|
prebuild.InitParametersArray(ids.Count);
|
|
if (ids.Count > 0) ids.CopyTo(prebuild.parameters);
|
|
entry.Debug.finalVeins = ids.ToArray();
|
|
coverage += ids.Count;
|
|
}
|
|
if (_allowVeinReform) RefreshVeins(buriedCount > 0 ? 1 : 0);
|
|
}
|
|
_debug.placedCount = placed.Count;
|
|
_debug.totalCoverage = coverage;
|
|
_debug.buriedCount = buriedCount;
|
|
if (placed.Count == 0) _debug.outcome = "no-placement";
|
|
_result = placed.Count == 0 ? I18NKeys.QuickMinerNoPlacement.Translate() :
|
|
string.Format(I18NKeys.QuickMinerResult.Translate(), placed.Count, coverage, buriedCount);
|
|
}
|
|
|
|
private bool NodesUnchanged(List<Candidate> layout)
|
|
{
|
|
foreach (var node in _nodes)
|
|
{
|
|
if (node.Id >= _factory.veinPool.Length) return false;
|
|
ref var vein = ref _factory.veinPool[node.Id];
|
|
if (vein.id != node.Id || vein.type != node.Type || vein.amount <= 0 || vein.colliderId <= 0 ||
|
|
(vein.pos - node.Position).sqrMagnitude > 0.0001f) return false;
|
|
}
|
|
if (!_allowVeinReform) return true;
|
|
var reserved = ReservedNodes();
|
|
foreach (var candidate in layout)
|
|
foreach (var index in candidate.Buried)
|
|
{
|
|
var id = _nodes[index].Id;
|
|
if (_factory.veinPool[id].minerCount > 0 || reserved.Contains(id)) return false;
|
|
}
|
|
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";
|
|
preview.ResetAll();
|
|
preview.item = _item;
|
|
preview.desc = _item.prefabDesc;
|
|
preview.lpos = preview.lpos2 = candidate.Position;
|
|
preview.lrot = preview.lrot2 = candidate.Rotation;
|
|
preview.condition = EBuildCondition.Ok;
|
|
validator.tmpInhandId = _item.ID;
|
|
validator.tmpInhandCount = 1;
|
|
var action = _player.controller.actionBuild;
|
|
var oldTest = _player.controller.cmd.test;
|
|
var oldCursorState = action.model.cursorState;
|
|
var oldCursorText = action.model.cursorText;
|
|
var oldCursor = UICursor.cursorIndex;
|
|
try
|
|
{
|
|
// CommandState is a struct; update the controller's field, not a local copy.
|
|
_player.controller.cmd.test = candidate.Position;
|
|
_physics.nearColliderLogic.ActiveCollidersInArea(candidate.Position, _footprintRadius + 16f);
|
|
// UpdateCursorNear does nothing outside build mode. Activate the native vein
|
|
// colliders explicitly so CheckBuildConditions still sees them from this button.
|
|
foreach (var node in _nodes)
|
|
{
|
|
var id = _factory.veinPool[node.Id].colliderId;
|
|
while (id > 0)
|
|
{
|
|
var collider = _physics.GetColliderData(id);
|
|
var objects = _physics.nearColliderLogic.colliderObjs;
|
|
if (objects.TryGetValue(id, out var existing)) existing.live = true;
|
|
else objects[id] = new ColliderObject(id, collider);
|
|
id = collider.link;
|
|
}
|
|
}
|
|
Physics.SyncTransforms();
|
|
var valid = validator.CheckBuildConditions();
|
|
debug.nativeCondition = preview.condition.ToString();
|
|
debug.coverObjectId = preview.coverObjId;
|
|
debug.nativeVeins = preview.parameters?.Take(preview.paramCount).ToArray() ?? [];
|
|
if (!valid || preview.condition != EBuildCondition.Ok || preview.coverObjId != 0) return false;
|
|
// Native selection includes nearby groups of the same type. Keep only this
|
|
// group and exclude all planned burials before enforcing the minimum.
|
|
debug.plannedVeins = debug.nativeVeins.Where(id => _factory.veinPool[id].groupIndex == _group &&
|
|
(!_allowVeinReform || !plannedBurial.Contains(id))).ToArray();
|
|
if (debug.plannedVeins.Length < MinerPlacementSolver.MinimumCoverage)
|
|
{ debug.outcome = "below-minimum-coverage"; return false; }
|
|
for (var i = 0; i < preview.paramCount; i++)
|
|
{
|
|
ref var vein = ref _factory.veinPool[preview.parameters[i]];
|
|
if (vein.id != preview.parameters[i] || vein.amount <= 0 || vein.type != _type) return false;
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
_player.controller.cmd.test = oldTest;
|
|
action.model.cursorState = oldCursorState;
|
|
action.model.cursorText = oldCursorText;
|
|
UICursor.cursorIndex = oldCursor;
|
|
}
|
|
}
|
|
|
|
private void SetVeinPosition(int id, Vector3 position)
|
|
{
|
|
ref var vein = ref _factory.veinPool[id];
|
|
vein.pos = position;
|
|
ref var collider = ref _physics.GetColliderDataRef(vein.colliderId);
|
|
collider.pos = position + position.normalized * 0.4f;
|
|
_physics.SetPlanetPhysicsColliderDirty();
|
|
GameMain.gpuiManager.AlterModel(vein.modelIndex, vein.modelId, id, position, setBuffer: false);
|
|
var proto = LDB.veins.Select((int)vein.type);
|
|
if (proto == null) return;
|
|
var up = position.normalized;
|
|
if (vein.minerId0 > 0)
|
|
{
|
|
GameMain.gpuiManager.AlterModel(proto.MinerBaseModelIndex, vein.minerBaseModelId, vein.minerId0, position + up * 0.1f, setBuffer: false);
|
|
GameMain.gpuiManager.AlterModel(proto.MinerCircleModelIndex, vein.minerCircleModelId0, vein.minerId0, position + up * 0.4f, setBuffer: false);
|
|
}
|
|
if (vein.minerId1 > 0) GameMain.gpuiManager.AlterModel(proto.MinerCircleModelIndex, vein.minerCircleModelId1, vein.minerId1, position + up * 0.6f, setBuffer: false);
|
|
if (vein.minerId2 > 0) GameMain.gpuiManager.AlterModel(proto.MinerCircleModelIndex, vein.minerCircleModelId2, vein.minerId2, position + up * 0.8f, setBuffer: false);
|
|
if (vein.minerId3 > 0) GameMain.gpuiManager.AlterModel(proto.MinerCircleModelIndex, vein.minerCircleModelId3, vein.minerId3, position + up, setBuffer: false);
|
|
}
|
|
|
|
private void RefreshVeins(int operation)
|
|
{
|
|
_physics.RefreshColliders();
|
|
GameMain.gpuiManager.SyncAllGPUBuffer();
|
|
if (operation != 0) GameMain.gameScenario?.NotifyOnVeinReformed(operation);
|
|
}
|
|
}
|
|
}
|