mirror of
https://github.com/soarqin/DSP_Mods.git
synced 2026-03-23 01:23:32 +08:00
781 lines
33 KiB
C#
781 lines
33 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using BepInEx.Configuration;
|
|
using UnityEngine;
|
|
|
|
namespace UXAssist.Functions;
|
|
|
|
public static class PlanetFunctions
|
|
{
|
|
public static ConfigEntry<int> OrbitalCollectorMaxBuildCount;
|
|
public static ConfigEntry<bool> ReturnBuildingsOnInitializeEnabled;
|
|
public static ConfigEntry<bool> ReturnLogisticStorageItemsOnInitializeEnabled;
|
|
public static ConfigEntry<bool> ReturnBeltAFactoryItemsOnInitializeEnabled;
|
|
|
|
private const int OrbitalCollectorItemId = 2105;
|
|
|
|
public static void DismantleAll(bool toBag)
|
|
{
|
|
var player = GameMain.mainPlayer;
|
|
if (player == null) return;
|
|
var planet = GameMain.localPlanet;
|
|
var factory = planet?.factory;
|
|
if (factory == null) return;
|
|
foreach (var etd in factory.entityPool)
|
|
{
|
|
var stationId = etd.stationId;
|
|
if (stationId > 0)
|
|
{
|
|
var sc = GameMain.localPlanet.factory.transport.stationPool[stationId];
|
|
if (sc is null || sc.id != stationId) continue;
|
|
if (toBag)
|
|
{
|
|
for (var i = sc.storage.Length - 1; i >= 0; i--)
|
|
{
|
|
var added = player.TryAddItemToPackage(sc.storage[i].itemId, sc.storage[i].count, sc.storage[i].inc, true, etd.id);
|
|
if (added > 0) UIItemup.Up(sc.storage[i].itemId, added);
|
|
sc.storage[i].count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (var i = sc.storage.Length - 1; i >= 0; i--)
|
|
{
|
|
sc.storage[i].count = 0;
|
|
}
|
|
}
|
|
}
|
|
if (toBag)
|
|
{
|
|
int protoId = 0;
|
|
factory.DismantleFinally(player, etd.id, ref protoId);
|
|
}
|
|
else
|
|
{
|
|
var objId = etd.id;
|
|
factory.BeforeDismantleObject(objId);
|
|
factory.RemoveEntityWithComponents(objId, false);
|
|
factory.OnDismantleObject(objId);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RecreatePlanet(bool revertReform)
|
|
{
|
|
var player = GameMain.mainPlayer;
|
|
if (player == null) return;
|
|
var planet = GameMain.localPlanet;
|
|
var factory = planet?.factory;
|
|
if (factory == null) return;
|
|
var uiGame = UIRoot.instance.uiGame;
|
|
if (uiGame)
|
|
{
|
|
uiGame.ShutAllFunctionWindow();
|
|
uiGame.ShutAllFullScreens();
|
|
}
|
|
player.controller.actionBuild.Close();
|
|
|
|
var groundCombatModule = player.mecha.groundCombatModule;
|
|
for (var i = groundCombatModule.moduleFleets.Length - 1; i >= 0; i--)
|
|
{
|
|
var entry = groundCombatModule.moduleFleets[i];
|
|
if (entry.fleetId <= 0 || !entry.fleetEnabled) continue;
|
|
entry.fleetEnabled = false;
|
|
groundCombatModule.RemoveFleetDirectly(i);
|
|
}
|
|
var constructionSystem = factory.constructionSystem;
|
|
var constructionModule = player.mecha.constructionModule;
|
|
for (var i = constructionSystem.drones.cursor - 1; i > 0; i--)
|
|
{
|
|
ref var drone = ref constructionSystem.drones.buffer[i];
|
|
if (drone.id <= 0) continue;
|
|
var owner = drone.owner;
|
|
constructionSystem.ResetDroneTargets(ref drone);
|
|
if (owner == 0)
|
|
{
|
|
factory.RemoveCraftWithComponents(drone.craftId);
|
|
constructionModule.droneIdleCount++;
|
|
}
|
|
else
|
|
{
|
|
drone.movement = factory.gameData.history.constructionDroneMovement;
|
|
factory.craftPool[drone.craftId].pos = constructionSystem.constructionModules[owner].baseEjectPos;
|
|
constructionSystem.constructionModules[owner].droneIdleCount++;
|
|
}
|
|
}
|
|
if (constructionSystem.constructStats?.buffer != null)
|
|
{
|
|
for (var i = constructionSystem.constructStats.cursor - 1; i > 0; i++)
|
|
{
|
|
ref var constructStat = ref constructionSystem.constructStats.buffer[i];
|
|
if (constructStat.id <= 0) continue;
|
|
constructionSystem.RemoveConstructStat(constructStat.id);
|
|
}
|
|
}
|
|
constructionModule.autoReconstructTargetTotalCount = 0;
|
|
constructionModule.buildTargetTotalCount = 0;
|
|
constructionModule.repairTargetTotalCount = 0;
|
|
constructionModule.autoReconstructTargets = null;
|
|
constructionModule.buildTargets = null;
|
|
constructionModule.repairTargets = null;
|
|
constructionModule.tmpTargets = null;
|
|
constructionModule.tmpTargetsHash = null;
|
|
constructionModule.checkItemCursor = 0;
|
|
|
|
var gameData = GameMain.data;
|
|
|
|
var returnBuildings = ReturnBuildingsOnInitializeEnabled.Value;
|
|
var returnLogisticStorageItems = ReturnLogisticStorageItemsOnInitializeEnabled.Value;
|
|
var returnBeltAFactoryItems = ReturnBeltAFactoryItemsOnInitializeEnabled.Value;
|
|
var returnedItems = new Dictionary<int, (long count, int inc)>();
|
|
|
|
static void AddReturnedItem(int itemId, int count, int inc, Dictionary<int, (long count, int inc)> returnedItems)
|
|
{
|
|
if (returnedItems.TryGetValue(itemId, out var value))
|
|
{
|
|
returnedItems[itemId] = (value.count + count, value.inc + inc);
|
|
}
|
|
else
|
|
{
|
|
returnedItems[itemId] = (count, inc);
|
|
}
|
|
}
|
|
|
|
if (returnBuildings || returnBeltAFactoryItems)
|
|
{
|
|
var factoryStorage = factory.factoryStorage;
|
|
var factorySystem = factory.factorySystem;
|
|
var planetTransport = factory.transport;
|
|
var defenseSystem = factory.defenseSystem;
|
|
var powerSystem = factory.powerSystem;
|
|
var cargoTraffic = factory.cargoTraffic;
|
|
for (var i = factory.entityCursor - 1; i > 0; i--)
|
|
{
|
|
ref var ed = ref factory.entityPool[i];
|
|
if (ed.id != i) continue;
|
|
if (ed.protoId <= 0) continue;
|
|
if (returnBuildings) AddReturnedItem(ed.protoId, 1, 0, returnedItems);
|
|
if (!returnBeltAFactoryItems) continue;
|
|
#region Storage Items
|
|
var storageId = ed.storageId;
|
|
if (storageId > 0)
|
|
{
|
|
var storage = factoryStorage.storagePool[storageId];
|
|
if (storage != null)
|
|
{
|
|
for (var j = storage.size - 1; j >= 0; j--)
|
|
{
|
|
var count = storage.grids[j].count;
|
|
if (count <= 0) continue;
|
|
AddReturnedItem(storage.grids[j].itemId, count, storage.grids[j].inc, returnedItems);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Tank Items
|
|
var tankId = ed.tankId;
|
|
if (tankId > 0)
|
|
{
|
|
ref var tank = ref factoryStorage.tankPool[tankId];
|
|
var fluidId = tank.fluidId;
|
|
var fluidCount = tank.fluidCount;
|
|
if (fluidId > 0 && fluidCount > 0) AddReturnedItem(fluidId, fluidCount, tank.fluidInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Miner Items
|
|
var minerId = ed.minerId;
|
|
if (minerId > 0)
|
|
{
|
|
ref var miner = ref factorySystem.minerPool[minerId];
|
|
var productId = miner.productId;
|
|
var productCount = miner.productCount;
|
|
if (productId > 0 && productCount > 0) AddReturnedItem(productId, productCount, 0, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Inserter Items
|
|
var inserterId = ed.inserterId;
|
|
if (inserterId > 0)
|
|
{
|
|
ref var inserter = ref factorySystem.inserterPool[inserterId];
|
|
var itemId = inserter.itemId;
|
|
var itemCount = inserter.itemCount;
|
|
if (itemId > 0 && itemCount > 0) AddReturnedItem(itemId, itemCount, inserter.itemInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Assembler Items
|
|
var assemblerId = ed.assemblerId;
|
|
if (assemblerId > 0)
|
|
{
|
|
ref var assembler = ref factorySystem.assemblerPool[assemblerId];
|
|
if (assembler.recipeId > 0)
|
|
{
|
|
var products = assembler.recipeExecuteData.products;
|
|
var requires = assembler.recipeExecuteData.requires;
|
|
var requireCounts = assembler.recipeExecuteData.requireCounts;
|
|
for (var j = products.Length - 1; j >= 0; j--)
|
|
{
|
|
var product = products[j];
|
|
var produced = assembler.produced[j];
|
|
if (produced > 0) AddReturnedItem(product, produced, 0, returnedItems);
|
|
}
|
|
for (var j = requires.Length - 1; j >= 0; j--)
|
|
{
|
|
var require = requires[j];
|
|
var served = assembler.served[j];
|
|
var incServed = assembler.incServed[j];
|
|
if (incServed > served * 10) incServed = served * 10;
|
|
if (assembler.replicating) served += requireCounts[j];
|
|
if (served > 0) AddReturnedItem(require, served, incServed, returnedItems);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Fractionator Items
|
|
var fractionatorId = ed.fractionatorId;
|
|
if (fractionatorId > 0)
|
|
{
|
|
ref var fractionator = ref factorySystem.fractionatorPool[fractionatorId];
|
|
var fluidId = fractionator.fluidId;
|
|
var fluidInputCount = fractionator.fluidInputCount;
|
|
if (fluidInputCount > 0) AddReturnedItem(fluidId, fluidInputCount, fractionator.fluidInputInc, returnedItems);
|
|
var fluidOutputCount = fractionator.fluidOutputCount;
|
|
if (fluidOutputCount > 0) AddReturnedItem(fluidId, fluidOutputCount, fractionator.fluidOutputInc, returnedItems);
|
|
var productOutputCount = fractionator.productOutputCount;
|
|
if (productOutputCount > 0) AddReturnedItem(fractionator.productId, productOutputCount, 0, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Ejector Items
|
|
var ejectorId = ed.ejectorId;
|
|
if (ejectorId > 0)
|
|
{
|
|
ref var ejector = ref factorySystem.ejectorPool[ejectorId];
|
|
var bulletCount = ejector.bulletCount;
|
|
if (bulletCount > 0) AddReturnedItem(ejector.bulletId, bulletCount, ejector.bulletInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Silo Items
|
|
var siloId = ed.siloId;
|
|
if (siloId > 0)
|
|
{
|
|
ref var silo = ref factorySystem.siloPool[siloId];
|
|
var itemCount = silo.bulletCount;
|
|
if (itemCount > 0) AddReturnedItem(silo.bulletId, itemCount, silo.bulletInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Lab Items
|
|
var labId = ed.labId;
|
|
if (labId > 0)
|
|
{
|
|
ref var lab = ref factorySystem.labPool[labId];
|
|
if (lab.recipeId > 0)
|
|
{
|
|
var products = lab.recipeExecuteData.products;
|
|
var requires = lab.recipeExecuteData.requires;
|
|
var requireCounts = lab.recipeExecuteData.requireCounts;
|
|
for (var j = products.Length - 1; j >= 0; j--)
|
|
{
|
|
var produced = lab.produced[j];
|
|
if (produced > 0) AddReturnedItem(products[j], produced, 0, returnedItems);
|
|
}
|
|
for (var j = requires.Length - 1; j >= 0; j--)
|
|
{
|
|
var served = lab.served[j];
|
|
var incServed = lab.incServed[j];
|
|
if (incServed > served * 10) incServed = served * 10;
|
|
if (lab.replicating) served += requireCounts[j];
|
|
if (served > 0) AddReturnedItem(requires[j], served, incServed, returnedItems);
|
|
}
|
|
}
|
|
if (lab.researchMode && lab.matrixServed != null)
|
|
{
|
|
for (var j = lab.matrixServed.Length - 1; j >= 0; j--)
|
|
{
|
|
var served = lab.matrixServed[j] / 3600;
|
|
if (served > 0) AddReturnedItem(LabComponent.matrixIds[j], served, lab.matrixIncServed[j] / 3600, returnedItems);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Dispenser Items
|
|
var dispenserId = ed.dispenserId;
|
|
if (dispenserId > 0)
|
|
{
|
|
var dispenser = planetTransport.dispenserPool[dispenserId];
|
|
var holdupPackage = dispenser.holdupPackage;
|
|
for (var j = holdupPackage.Length - 1; j >= 0; j--)
|
|
{
|
|
var count = holdupPackage[j].count;
|
|
if (count > 0) AddReturnedItem(holdupPackage[j].itemId, count, holdupPackage[j].inc, returnedItems);
|
|
}
|
|
var courierCount = dispenser.idleCourierCount + dispenser.workCourierCount;
|
|
if (courierCount > 0) AddReturnedItem((int)Common.KnownItemId.Bot, courierCount, 0, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Turret Items
|
|
var turretId = ed.turretId;
|
|
if (turretId > 0)
|
|
{
|
|
ref var turret = ref defenseSystem.turrets.buffer[turretId];
|
|
var itemCount = turret.itemCount;
|
|
if (itemCount > 0) AddReturnedItem(turret.itemId, itemCount, turret.itemInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Battle Base Items
|
|
var battleBaseId = ed.battleBaseId;
|
|
if (battleBaseId > 0)
|
|
{
|
|
ref var battleBase = ref defenseSystem.battleBases.buffer[battleBaseId];
|
|
var combatModule = battleBase.combatModule;
|
|
if (combatModule != null && combatModule.moduleFleets[0].fleetId <= 0)
|
|
{
|
|
var fighters = combatModule.moduleFleets[0].fighters;
|
|
for (var j = fighters.Length - 1; j >= 0; j--)
|
|
{
|
|
var fighterItemId = fighters[j].itemId;
|
|
var fighterCount = fighters[j].count;
|
|
if (fighterItemId > 0 && fighterCount > 0) AddReturnedItem(fighterItemId, fighterCount, 0, returnedItems);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Power Generator Items
|
|
var powerGeneratorId = ed.powerGenId;
|
|
if (powerGeneratorId > 0)
|
|
{
|
|
ref var powerGen = ref powerSystem.genPool[powerGeneratorId];
|
|
if (powerGen.fuelId > 0 && powerGen.fuelCount > 0) AddReturnedItem(powerGen.fuelId, powerGen.fuelCount, powerGen.fuelInc, returnedItems);
|
|
if (powerGen.gamma)
|
|
{
|
|
var productId = powerGen.productId;
|
|
var productCount = (int)powerGen.productCount;
|
|
if (productId != 0 && productCount > 0) AddReturnedItem(productId, productCount, 0, returnedItems);
|
|
int catalystId = powerGen.catalystId;
|
|
var catalystPointDiv = powerGen.catalystPoint / 3600;
|
|
if (catalystId != 0 && catalystPointDiv > 0) AddReturnedItem(catalystId, catalystPointDiv, powerGen.catalystIncPoint / 3600, returnedItems);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Power Exchanger Items
|
|
var powerExchangerId = ed.powerExcId;
|
|
if (powerExchangerId > 0)
|
|
{
|
|
ref var powerExchanger = ref powerSystem.excPool[powerExchangerId];
|
|
var emptyCount = (int)powerExchanger.emptyCount;
|
|
if (emptyCount > 0) AddReturnedItem(powerExchanger.emptyId, emptyCount, powerExchanger.emptyInc, returnedItems);
|
|
var fullCount = (int)powerExchanger.fullCount;
|
|
if (fullCount > 0) AddReturnedItem(powerExchanger.fullId, fullCount, powerExchanger.fullInc, returnedItems);
|
|
}
|
|
#endregion
|
|
#region Spraycoater Items
|
|
var spraycoaterId = ed.spraycoaterId;
|
|
if (spraycoaterId > 0)
|
|
{
|
|
ref var spraycoater = ref cargoTraffic.spraycoaterPool[spraycoaterId];
|
|
if (spraycoater.incItemId != 0 && spraycoater.incCount != 0)
|
|
{
|
|
var itemProto = LDB.items.Select(spraycoater.incItemId);
|
|
var count = spraycoater.incCount / itemProto.HpMax;
|
|
if (count != 0) AddReturnedItem(spraycoater.incItemId, count, 0, returnedItems);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Piler Items
|
|
var pilerId = ed.pilerId;
|
|
if (pilerId > 0)
|
|
{
|
|
ref var piler = ref cargoTraffic.pilerPool[pilerId];
|
|
var cacheCargoStack = (int)piler.cacheCargoStack1;
|
|
if (cacheCargoStack > 0) AddReturnedItem(piler.cacheItemId1, cacheCargoStack, piler.cacheCargoInc1, returnedItems);
|
|
var cacheCargoStack2 = (int)piler.cacheCargoStack2;
|
|
if (cacheCargoStack2 > 0) AddReturnedItem(piler.cacheItemId2, cacheCargoStack2, piler.cacheCargoInc2, returnedItems);
|
|
}
|
|
#endregion
|
|
}
|
|
if (returnBeltAFactoryItems)
|
|
{
|
|
#region Belt Items
|
|
for (var i = cargoTraffic.pathCursor - 1; i > 0; i--)
|
|
{
|
|
var cargoPath = cargoTraffic.pathPool[i];
|
|
if (cargoPath == null) continue;
|
|
var end = cargoPath.bufferLength - 5;
|
|
var buffer = cargoPath.buffer;
|
|
for (var j = 0; j <= end;)
|
|
{
|
|
if (buffer[j] >= 246)
|
|
{
|
|
j += 250 - buffer[j];
|
|
var bufferIndex = buffer[j + 1] - 1 + (buffer[j + 2] - 1) * 100 + (buffer[j + 3] - 1) * 10000 + (buffer[j + 4] - 1) * 1000000;
|
|
ref var cargo = ref cargoPath.cargoContainer.cargoPool[bufferIndex];
|
|
var stack = cargo.stack;
|
|
if (stack > 0) AddReturnedItem(cargo.item, stack, cargo.inc, returnedItems);
|
|
j += 10;
|
|
}
|
|
else
|
|
{
|
|
j += 5;
|
|
if (j > end && j < end + 5)
|
|
{
|
|
j = end;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
var stationPool = factory.transport?.stationPool;
|
|
if (stationPool != null)
|
|
{
|
|
var galacticTransport = gameData.galacticTransport;
|
|
for (var i = factory.transport.stationCursor - 1; i > 0; i--)
|
|
{
|
|
var sc = stationPool[i];
|
|
if (sc == null || sc.id != i) continue;
|
|
if (returnLogisticStorageItems)
|
|
{
|
|
for (var j = sc.storage.Length - 1; j >= 0; j--)
|
|
{
|
|
var count = sc.storage[j].count;
|
|
if (count > 0) AddReturnedItem(sc.storage[j].itemId, count, sc.storage[j].inc, returnedItems);
|
|
}
|
|
var droneCount = sc.idleDroneCount + sc.workDroneCount;
|
|
if (droneCount > 0) AddReturnedItem((int)Common.KnownItemId.Drone, droneCount, 0, returnedItems);
|
|
var shipCount = sc.idleShipCount + sc.workShipCount;
|
|
if (shipCount > 0) AddReturnedItem((int)Common.KnownItemId.Ship, shipCount, 0, returnedItems);
|
|
var warperCount = sc.warperCount;
|
|
if (warperCount > 0) AddReturnedItem((int)Common.KnownItemId.Warper, warperCount, 0, returnedItems);
|
|
}
|
|
var gid = sc.gid;
|
|
if (galacticTransport.stationPool[gid] != null)
|
|
{
|
|
galacticTransport.stationPool[gid] = null;
|
|
int cursor = galacticTransport.stationRecycleCursor;
|
|
galacticTransport.stationRecycleCursor = cursor + 1;
|
|
galacticTransport.stationRecycle[cursor] = gid;
|
|
}
|
|
galacticTransport.RemoveStation2StationRoute(gid);
|
|
galacticTransport.RefreshTraffic(gid);
|
|
sc.Reset();
|
|
}
|
|
if (galacticTransport.OnStellarStationRemoved != null)
|
|
{
|
|
galacticTransport.OnStellarStationRemoved();
|
|
}
|
|
}
|
|
|
|
var physics = planet.physics;
|
|
var gpuiManager = GameMain.gpuiManager;
|
|
var blockContainer = factory.blockContainer;
|
|
var audio = planet.audio;
|
|
for (var id = factory.entityCursor - 1; id > 0; id--)
|
|
{
|
|
ref var ed = ref factory.entityPool[id];
|
|
if (ed.id != id) continue;
|
|
|
|
factory.BeforeDismantleObject(id);
|
|
|
|
if (ed.colliderId != 0)
|
|
{
|
|
physics.RemoveLinkedColliderData(ed.colliderId);
|
|
physics.NotifyObjectRemove(EObjectType.Entity, ed.id);
|
|
}
|
|
|
|
if (ed.modelId != 0)
|
|
{
|
|
gpuiManager.RemoveModel(ed.modelIndex, ed.modelId);
|
|
}
|
|
|
|
if (ed.mmblockId != 0)
|
|
{
|
|
blockContainer.RemoveMiniBlock(ed.mmblockId);
|
|
}
|
|
|
|
if (ed.audioId != 0)
|
|
{
|
|
audio.RemoveAudioData(ed.audioId);
|
|
}
|
|
|
|
factory.OnDismantleObject(id);
|
|
}
|
|
|
|
for (var id = factory.prebuildCursor - 1; id > 0; id--)
|
|
{
|
|
ref var pb = ref factory.prebuildPool[id];
|
|
if (pb.id != id) continue;
|
|
if (pb.colliderId != 0)
|
|
{
|
|
physics.RemoveLinkedColliderData(pb.colliderId);
|
|
}
|
|
if (pb.modelId != 0)
|
|
{
|
|
gpuiManager.RemovePrebuildModel(pb.modelIndex, pb.modelId);
|
|
}
|
|
}
|
|
|
|
var hives = GameMain.spaceSector?.dfHives;
|
|
if (hives != null)
|
|
{
|
|
var hive = hives[planet.star.index];
|
|
var relays = hive?.relays?.buffer;
|
|
if (relays != null)
|
|
{
|
|
var astroId = planet.astroId;
|
|
for (var i = relays.Length - 1; i >= 0; i--)
|
|
{
|
|
var relay = relays[i];
|
|
if (relay == null || relay.id != i) continue;
|
|
if (relay.targetAstroId != astroId && relay.searchAstroId != astroId) continue;
|
|
relay.targetAstroId = 0;
|
|
relay.searchAstroId = 0;
|
|
if (relay.baseId > 0)
|
|
hive.relayNeutralizedCounter++;
|
|
relay.LeaveBase();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (factory.enemyPool != null)
|
|
{
|
|
for (var i = factory.enemyCursor - 1; i > 0; i--)
|
|
{
|
|
ref var enemyData = ref factory.enemyPool[i];
|
|
if (enemyData.id != i) continue;
|
|
var combatStatId = enemyData.combatStatId;
|
|
factory.skillSystem.OnRemovingSkillTarget(combatStatId, factory.skillSystem.combatStats.buffer[combatStatId].originAstroId, ETargetType.CombatStat);
|
|
factory.skillSystem.combatStats.Remove(combatStatId);
|
|
factory.KillEnemyFinally(i, ref CombatStat.empty);
|
|
}
|
|
factory.enemySystem.Free();
|
|
UIRoot.instance.uiGame.dfAssaultTip.ClearAllSpots();
|
|
}
|
|
|
|
var planetId = planet.id;
|
|
var gameScenario = GameMain.gameScenario;
|
|
if (gameScenario != null)
|
|
{
|
|
var genPool = factory.powerSystem?.genPool;
|
|
if (genPool != null)
|
|
{
|
|
foreach (var pgc in genPool)
|
|
{
|
|
if (pgc.id <= 0) continue;
|
|
int protoId = factory.entityPool[pgc.entityId].protoId;
|
|
gameScenario.achievementLogic.NotifyBeforeDismantleEntity(planetId, protoId, pgc.entityId);
|
|
gameScenario.NotifyOnDismantleEntity(planetId, protoId, pgc.entityId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (revertReform)
|
|
{
|
|
factory.PlanetReformRevert();
|
|
}
|
|
|
|
gameData.LeavePlanet();
|
|
var index = factory.index;
|
|
var warningSystem = gameData.warningSystem;
|
|
var warningPool = warningSystem.warningPool;
|
|
for (var i = warningSystem.warningCursor - 1; i >= 0; i--)
|
|
{
|
|
ref var warning = ref warningPool[i];
|
|
if (warning.id != i) continue;
|
|
switch (warning.factoryId)
|
|
{
|
|
case -4:
|
|
if (warning.astroId == planetId)
|
|
warningSystem.RemoveWarningData(i);
|
|
break;
|
|
case >= 0:
|
|
if (warning.factoryId == index)
|
|
warningSystem.RemoveWarningData(i);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
var isCombatMode = factory.gameData.gameDesc.isCombatMode;
|
|
factory.entityCursor = 1;
|
|
factory.entityRecycleCursor = 0;
|
|
factory.entityCapacity = 0;
|
|
factory.SetEntityCapacity(1024);
|
|
factory.craftCursor = 1;
|
|
factory.craftRecycleCursor = 0;
|
|
factory.craftCapacity = 0;
|
|
factory.SetCraftCapacity(128);
|
|
factory.prebuildCursor = 1;
|
|
factory.prebuildRecycleCursor = 0;
|
|
factory.prebuildCapacity = 0;
|
|
factory.SetPrebuildCapacity(256);
|
|
factory.enemyCursor = 1;
|
|
factory.enemyRecycleCursor = 0;
|
|
factory.enemyCapacity = 0;
|
|
factory.SetEnemyCapacity(isCombatMode ? 1024 : 32);
|
|
factory.hashSystemDynamic = new HashSystem();
|
|
factory.hashSystemStatic = new HashSystem();
|
|
factory.cargoContainer = new CargoContainer();
|
|
factory.cargoTraffic = new CargoTraffic(planet);
|
|
factory.blockContainer = new MiniBlockContainer();
|
|
factory.factoryStorage = new FactoryStorage(planet);
|
|
factory.powerSystem = new PowerSystem(planet);
|
|
factory.constructionSystem = new ConstructionSystem(planet);
|
|
if (factory.veinPool != null)
|
|
{
|
|
for (var i = factory.veinPool.Length - 1; i >= 0; i--)
|
|
{
|
|
ref var vein = ref factory.veinPool[i];
|
|
if (vein.id != i) continue;
|
|
vein.minerCount = 0;
|
|
vein.minerId0 = 0;
|
|
vein.minerId1 = 0;
|
|
vein.minerId2 = 0;
|
|
vein.minerId3 = 0;
|
|
}
|
|
}
|
|
factory.InitVeinHashAddress();
|
|
factory.RecalculateAllVeinGroups();
|
|
factory.InitVegeHashAddress();
|
|
factory.ruinCursor = 1;
|
|
factory.ruinRecycleCursor = 0;
|
|
factory.ruinCapacity = 0;
|
|
factory.SetRuinCapacity(isCombatMode ? 1024 : 32);
|
|
factory.factorySystem = new FactorySystem(planet);
|
|
factory.enemySystem = new EnemyDFGroundSystem(planet);
|
|
factory.combatGroundSystem = new CombatGroundSystem(planet);
|
|
factory.defenseSystem = new DefenseSystem(planet);
|
|
factory.planetATField = new PlanetATField(planet);
|
|
factory.transport = new PlanetTransport(gameData, planet);
|
|
factory.transport.Init();
|
|
factory.RefreshHashSystems();
|
|
var mem = new MemoryStream();
|
|
var writer = new BinaryWriter(mem);
|
|
factory.platformSystem.Export(writer);
|
|
factory.platformSystem = new PlatformSystem(planet, true);
|
|
mem.Position = 0;
|
|
var reader = new BinaryReader(mem);
|
|
factory.platformSystem.Import(reader);
|
|
mem.Close();
|
|
mem.Dispose();
|
|
factory.digitalSystem = new DigitalSystem(planet);
|
|
|
|
//GameMain.data.statistics.production.CreateFactoryStat(index);
|
|
gameData.ArrivePlanet(planet);
|
|
|
|
foreach (var kvp in returnedItems)
|
|
{
|
|
var added = player.TryAddItemToPackage(kvp.Key, (int)kvp.Value.count, kvp.Value.inc, true);
|
|
if (added > 0) UIItemup.Up(kvp.Key, added);
|
|
}
|
|
}
|
|
|
|
public static void BuildOrbitalCollectors()
|
|
{
|
|
var player = GameMain.mainPlayer;
|
|
if (player == null) return;
|
|
var planet = GameMain.localPlanet;
|
|
if (planet is not { type: EPlanetType.Gas }) return;
|
|
var countToBuild = OrbitalCollectorMaxBuildCount.Value;
|
|
if (countToBuild == 0) countToBuild = -1;
|
|
|
|
var factory = planet.factory;
|
|
var stationPool = factory.transport.stationPool;
|
|
var stationCursor = factory.transport.stationCursor;
|
|
var entityPool = factory.entityPool;
|
|
var pos = new Vector3(0f, 0f, planet.realRadius * 1.025f + 0.2f);
|
|
var found = false;
|
|
for (var i = stationCursor - 1; i > 0; i--)
|
|
{
|
|
if (stationPool[i] == null || stationPool[i].id != i) continue;
|
|
ref var entity = ref entityPool[stationPool[i].entityId];
|
|
pos = entity.pos;
|
|
found = true;
|
|
break;
|
|
}
|
|
var prebuildCursor = factory.prebuildCursor;
|
|
var prebuildPool = factory.prebuildPool;
|
|
if (!found)
|
|
{
|
|
for (var i = prebuildCursor - 1; i > 0; i--)
|
|
{
|
|
if (prebuildPool[i].id != i) continue;
|
|
pos = prebuildPool[i].pos;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var testPos = pos;
|
|
var cellCount = PlanetGrid.DetermineLongitudeSegmentCount(0, factory.planet.aux.mainGrid.segment) * 5;
|
|
var cellRad = Math.PI / cellCount;
|
|
var distRadCount = 1;
|
|
for (var i = 1; i <= cellCount; i++)
|
|
{
|
|
testPos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad, testPos);
|
|
if ((testPos - pos).sqrMagnitude < 14297f) continue;
|
|
distRadCount = i;
|
|
break;
|
|
}
|
|
for (var i = 0; i < cellCount && countToBuild != 0;)
|
|
{
|
|
/* Check for collision */
|
|
var collide = false;
|
|
for (var j = stationCursor - 1; j > 0; j--)
|
|
{
|
|
if (stationPool[j] == null || stationPool[j].id != j) continue;
|
|
if ((entityPool[stationPool[j].entityId].pos - pos).sqrMagnitude >= 14297f) continue;
|
|
collide = true;
|
|
break;
|
|
}
|
|
for (var j = 1; j < prebuildCursor; j++)
|
|
{
|
|
if (prebuildPool[j].id != j) continue;
|
|
if ((prebuildPool[j].pos - pos).sqrMagnitude >= 14297f) continue;
|
|
collide = true;
|
|
break;
|
|
}
|
|
if (collide)
|
|
{
|
|
/* rotate for a small cell on sphere */
|
|
pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad, pos);
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (player.inhandItemId == OrbitalCollectorItemId && player.inhandItemCount > 0)
|
|
{
|
|
player.UseHandItems(1, out var _);
|
|
}
|
|
else
|
|
{
|
|
var count = 1;
|
|
var itemId = OrbitalCollectorItemId;
|
|
player.package.TakeTailItems(ref itemId, ref count, out var _);
|
|
if (count == 0) break;
|
|
}
|
|
|
|
var rot = Maths.SphericalRotation(pos, 0f);
|
|
var prebuild = new PrebuildData
|
|
{
|
|
protoId = 2105,
|
|
modelIndex = 117,
|
|
pos = pos,
|
|
pos2 = pos,
|
|
rot = rot,
|
|
rot2 = rot,
|
|
pickOffset = 0,
|
|
insertOffset = 0,
|
|
recipeId = 0,
|
|
filterId = 0,
|
|
paramCount = 0
|
|
};
|
|
factory.AddPrebuildDataWithComponents(prebuild);
|
|
prebuildCursor = factory.prebuildCursor;
|
|
if (countToBuild > 0) countToBuild--;
|
|
/* rotate for minimal distance for next OC on sphere */
|
|
pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad * distRadCount, pos);
|
|
i += distRadCount;
|
|
}
|
|
}
|
|
}
|