public static void Sort_Postfix(StorageComponent __instance)
{
if (SimulatedWorld.Initialized && !StorageManager.IsIncomingRequest && GameMain.data.localPlanet != null)
{
HandleUserInteraction(__instance, new StorageSyncSortPacket(__instance.id, GameMain.data.localPlanet.id));
}
}
public static void OnManualServingContentChange_Postfix(UISiloWindow __instance)
{
//Notify about manual rockets inserting / withdrawing change
StorageComponent storage = (StorageComponent)AccessTools.Field(typeof(UISiloWindow), "servingStorage").GetValue(__instance);
LocalPlayer.SendPacketToLocalStar(new SiloStorageUpdatePacket(__instance.siloId, storage.grids[0].count, GameMain.localPlanet?.factoryIndex ?? -1));
}
public static void load(StorageComponent storage)
{
colors = new List <Color>();
data = storage.LoadData <byte>("colors.lst");
if (data == null)
{
data = new DataType <byte>(21);
data.fillList(0);
resetColors();
saveColors();
storage.SaveData <byte>(data, "colors.lst");
}
else
{
for (int i = 0; i < 7; i++)
{
colors.Add(new Color(data.list[i], data.list[i + 7], data.list[i + 14]));
}
}
}
public void ProcessPacket(StorageSyncRealtimeChangePacket packet, NebulaConnection conn)
{
StorageComponent storageComponent = null;
StorageComponent[] pool = GameMain.data.factories[packet.FactoryIndex]?.factoryStorage?.storagePool;
if (pool != null && packet.StorageIndex != -1 && packet.StorageIndex < pool.Length)
{
storageComponent = pool[packet.StorageIndex];
}
if (storageComponent != null)
{
using (StorageManager.EventFromServer.On())
{
int itemId = packet.ItemId;
int count = packet.Count;
if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.AddItem2)
{
storageComponent.AddItem(packet.ItemId, packet.Count, packet.StartIndex, packet.Length);
}
else if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.AddItemStacked)
{
storageComponent.AddItemStacked(packet.ItemId, packet.Count);
}
else if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.TakeItemFromGrid)
{
storageComponent.TakeItemFromGrid(packet.Length, ref itemId, ref count);
}
}
}
}
public void ProcessPacket(StorageSyncRealtimeChangePacket packet, NebulaConnection conn)
{
int itemId = packet.ItemId;
int count = packet.Count;
StorageComponent storage = null;
StorageComponent[] pool = GameMain.localPlanet?.factory?.factoryStorage?.storagePool;
if (pool != null && packet.StorageIndex != -1 && packet.StorageIndex < pool.Length)
{
storage = pool[packet.StorageIndex];
}
if (storage != null)
{
StorageManager.EventFromClient = true;
if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.TakeItemFromGrid)
{
storage.TakeItemFromGrid(packet.Length, ref itemId, ref count);
StorageSyncManager.SendToOtherPlayersOnTheSamePlanet(conn, packet, packet.PlanetId);
}
else if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.AddItem2)
{
storage.AddItem(itemId, count, packet.StartIndex, packet.Length);
StorageSyncManager.SendToOtherPlayersOnTheSamePlanet(conn, packet, packet.PlanetId);
}
else if (packet.StorageEvent == StorageSyncRealtimeChangeEvent.AddItemStacked)
{
int result = storage.AddItemStacked(itemId, count);
StorageSyncManager.SendToOtherPlayersOnTheSamePlanet(conn, packet, packet.PlanetId);
}
StorageManager.EventFromClient = false;
}
}
public static void SetBans_Postfix(StorageComponent __instance, int _bans)
{
if (SimulatedWorld.Initialized && !StorageManager.IsIncomingRequest)
{
HandleUserInteraction(__instance, new StorageSyncSetBansPacket(__instance.id, GameMain.data.localPlanet.id, _bans));
}
}
public override void ProcessPacket(StorageSyncResponsePacket packet, NebulaConnection conn)
{
if (IsHost)
{
return;
}
StorageComponent storageComponent = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory?.factoryStorage?.storagePool[packet.StorageIndex];
if (storageComponent != null)
{
using (BinaryUtils.Reader reader = new BinaryUtils.Reader(packet.StorageComponent))
{
storageComponent.Import(reader.BinaryReader);
}
ItemProto itemProto = LDB.items.Select((int)GameMain.galaxy.PlanetById(packet.PlanetId)?.factory?.entityPool[storageComponent.entityId].protoId);
//Imitation of UIStorageWindow.OnStorageIdChange()
Multiplayer.Session.Storage.ActiveWindowTitle.text = itemProto.name;
Multiplayer.Session.Storage.ActiveUIStorageGrid._Free();
Multiplayer.Session.Storage.ActiveUIStorageGrid._Init(storageComponent);
Multiplayer.Session.Storage.ActiveStorageComponent = storageComponent;
Multiplayer.Session.Storage.ActiveUIStorageGrid.SetStorageData(Multiplayer.Session.Storage.ActiveStorageComponent);
Multiplayer.Session.Storage.ActiveUIStorageGrid._Open();
Multiplayer.Session.Storage.ActiveUIStorageGrid.OnStorageDataChanged();
Multiplayer.Session.Storage.ActiveBansSlider.maxValue = storageComponent.size;
Multiplayer.Session.Storage.ActiveBansSlider.value = storageComponent.size - storageComponent.bans;
Multiplayer.Session.Storage.ActiveBansValueText.text = Multiplayer.Session.Storage.ActiveBansSlider.value.ToString();
GameMain.galaxy.PlanetById(packet.PlanetId).factory.factoryStorage.storagePool[packet.StorageIndex] = storageComponent;
}
}
public static WorldEditWorldObjectBlockData From(WorldObject worldObject)
{
WorldEditWorldObjectBlockData worldObjectData = new WorldEditWorldObjectBlockData();
worldObjectData.WorldObjectType = worldObject.GetType();
worldObjectData.Rotation = worldObject.Rotation;
worldObjectData.Components = new Dictionary <Type, Object>();
if (worldObject.HasComponent <StorageComponent>())
{
StorageComponent storageComponent = worldObject.GetComponent <StorageComponent>();
List <InventoryStack> inventoryStacks = new List <InventoryStack>();
foreach (ItemStack stack in storageComponent.Inventory.Stacks)
{
if (stack.Empty())
{
continue;
}
inventoryStacks.Add(InventoryStack.Create(stack));
}
worldObjectData.Components.Add(typeof(StorageComponent), inventoryStacks);
}
if (worldObject.HasComponent <CustomTextComponent>())
{
CustomTextComponent textComponent = worldObject.GetComponent <CustomTextComponent>();
worldObjectData.Components.Add(typeof(CustomTextComponent), textComponent.TextData.Text);
}
return(worldObjectData);
}
private StorageComponent getNearestStorageComponent(Vector3 currentPosition)
{
StorageComponent[] storageComponents = (StorageComponent[])UnityEngine.GameObject.FindObjectsOfType(typeof(StorageComponent));
StorageComponent closest = null;
float closestDist = 0;
foreach (StorageComponent storageComponent in storageComponents)
{
if (closest == null)
{
closest = storageComponent;
closestDist = (storageComponent.gameObject.transform.position - currentPosition).magnitude;
}
else
{
float dist = (storageComponent.gameObject.transform.position - currentPosition).magnitude;
if (dist < closestDist)
{
closest = storageComponent;
closestDist = dist;
}
}
}
if (closest == null)
{
Stop();
}
return(closest);
}
public void Deserialize(NetDataReader reader)
{
TechBonuses = new PlayerTechBonuses();
Inventory = new StorageComponent(4);
ReactorStorage = new StorageComponent(4);
WarpStorage = new StorageComponent(1);
Forge = new MechaForge();
Forge.tasks = new List <ForgeTask>();
Forge.extraItems = new ItemPack();
TechBonuses.Deserialize(reader);
SandCount = reader.GetInt();
CoreEnergy = reader.GetDouble();
ReactorEnergy = reader.GetDouble();
bool isPayloadPresent = reader.GetBool();
if (isPayloadPresent)
{
int mechaLength = reader.GetInt();
byte[] mechaBytes = new byte[mechaLength];
reader.GetBytes(mechaBytes, mechaLength);
using (MemoryStream ms = new MemoryStream(mechaBytes))
using (BinaryReader br = new BinaryReader(ms))
{
Inventory.Import(br);
ReactorStorage.Import(br);
WarpStorage.Import(br);
Forge.Import(br);
}
}
}
public static void Sort_Postfix(StorageComponent __instance)
{
if (SimulatedWorld.Initialized && !StorageManager.EventFromServer && !StorageManager.EventFromClient)
{
HandleUserInteraction(__instance, new StorageSyncSortPacket(__instance.id, GameMain.data.localPlanet.factoryIndex));
}
}
public static void Sort_Postfix(StorageComponent __instance)
{
if (Multiplayer.IsActive && !Multiplayer.Session.Storage.IsIncomingRequest && GameMain.data.localPlanet != null)
{
HandleUserInteraction(__instance, new StorageSyncSortPacket(__instance.id, GameMain.data.localPlanet.id));
}
}
public void ProcessPacket(StorageSyncResponsePacket packet, NebulaConnection conn)
{
StorageComponent storageComponent = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory?.factoryStorage?.storagePool[packet.StorageIndex];
if (storageComponent != null)
{
using (BinaryUtils.Reader reader = new BinaryUtils.Reader(packet.StorageComponent))
{
storageComponent.Import(reader.BinaryReader);
}
ItemProto itemProto = LDB.items.Select((int)GameMain.galaxy.PlanetById(packet.PlanetId)?.factory?.entityPool[storageComponent.entityId].protoId);
//Imitation of UIStorageWindow.OnStorageIdChange()
StorageManager.ActiveWindowTitle.text = itemProto.name;
StorageManager.ActiveUIStorageGrid._Free();
StorageManager.ActiveUIStorageGrid._Init(storageComponent);
StorageManager.ActiveStorageComponent = storageComponent;
MethodInvoker.GetHandler(AccessTools.Method(typeof(UIStorageGrid), "SetStorageData")).Invoke(StorageManager.ActiveUIStorageGrid, StorageManager.ActiveStorageComponent);
StorageManager.ActiveUIStorageGrid._Open();
StorageManager.ActiveUIStorageGrid.OnStorageDataChanged();
StorageManager.ActiveBansSlider.maxValue = (float)storageComponent.size;
StorageManager.ActiveBansSlider.value = (float)(storageComponent.size - storageComponent.bans);
StorageManager.ActiveBansValueText.text = StorageManager.ActiveBansSlider.value.ToString();
GameMain.galaxy.PlanetById(packet.PlanetId).factory.factoryStorage.storagePool[packet.StorageIndex] = storageComponent;
}
}
public static void OnManualServingContentChange_Postfix(UIEjectorWindow __instance)
{
//Notify about manual bullet inserting / withdrawing change
StorageComponent storage = (StorageComponent)AccessTools.Field(typeof(UIEjectorWindow), "servingStorage").GetValue(__instance);
LocalPlayer.SendPacketToLocalPlanet(new EjectorStorageUpdatePacket(__instance.ejectorId, storage.grids[0].count));
}
public static void RestoreWorldObjectBlock(Type type, Vector3i position, IWorldEditBlockData blockData, UserSession session)
{
if (blockData == null)
{
return;
}
WorldEditWorldObjectBlockData worldObjectBlockData = (WorldEditWorldObjectBlockData)blockData;
ClearWorldObjectPlace(worldObjectBlockData.WorldObjectType, position, worldObjectBlockData.Rotation, session);
WorldObject worldObject = null;
try { worldObject = WorldObjectManager.ForceAdd(worldObjectBlockData.WorldObjectType, session.User, position, worldObjectBlockData.Rotation, true); }
catch (Exception e)
{
Log.WriteException(e);
}
if (worldObject == null)
{
Log.WriteErrorLineLoc($"Unable spawn WorldObject {worldObjectBlockData.WorldObjectType} at {position}");
return;
}
if (worldObject.HasComponent <StorageComponent>() && worldObjectBlockData.Components.ContainsKey(typeof(StorageComponent)))
{
StorageComponent storageComponent = worldObject.GetComponent <StorageComponent>();
List <InventoryStack> inventoryStacks;
object component = worldObjectBlockData.Components[typeof(StorageComponent)];
if (component is JArray)
{
JArray jArray = (JArray)component;
inventoryStacks = jArray.ToObject <List <InventoryStack> >();
}
else
{
inventoryStacks = (List <InventoryStack>)component;
}
foreach (InventoryStack stack in inventoryStacks)
{
if (stack.ItemType == null)
{
continue;
}
Result result = storageComponent.Inventory.TryAddItems(stack.ItemType, stack.Quantity);
if (result.Failed)
{
session.Player.ErrorLocStr(result.Message.Trim());
try { storageComponent.Inventory.AddItems(stack.GetItemStack()); } catch (InvalidOperationException) { /*Already show error to user*/ }
}
}
}
if (worldObject.HasComponent <CustomTextComponent>() && worldObjectBlockData.Components.ContainsKey(typeof(CustomTextComponent)))
{
CustomTextComponent textComponent = worldObject.GetComponent <CustomTextComponent>();
textComponent.TextData.Text = (string)worldObjectBlockData.Components[typeof(CustomTextComponent)];
}
}
public static bool TakeItemFromGrid_Prefix(StorageComponent __instance, int gridIndex, ref int itemId, ref int count)
{
//Run only in MP, if it is not triggered remotly and if this event was triggered manually by an user
if (SimulatedWorld.Initialized && !StorageManager.IsIncomingRequest && StorageManager.IsHumanInput && GameMain.data.localPlanet != null)
{
HandleUserInteraction(__instance, new StorageSyncRealtimeChangePacket(__instance.id, StorageSyncRealtimeChangeEvent.TakeItemFromGrid, gridIndex, itemId, count));
}
return(true);
}
public static bool AddItem_Prefix(StorageComponent __instance, int itemId, int count, int startIndex, int length)
{
//Run only in MP, if it is not triggered remotly and if this event was triggered manually by an user
if (SimulatedWorld.Initialized && !StorageManager.EventFromServer && !StorageManager.EventFromClient && StorageManager.IsHumanInput)
{
HandleUserInteraction(__instance, new StorageSyncRealtimeChangePacket(__instance.id, StorageSyncRealtimeChangeEvent.AddItem2, itemId, count, startIndex, length));
}
return(true);
}
public static void OnManualServingContentChange_Postfix(UISiloWindow __instance)
{
//Notify about manual rockets inserting / withdrawing change
if (Multiplayer.IsActive)
{
StorageComponent storage = __instance.servingStorage;
Multiplayer.Session.Network.SendPacketToLocalStar(new SiloStorageUpdatePacket(__instance.siloId, storage.grids[0].count, storage.grids[0].inc, GameMain.localPlanet?.id ?? -1));
}
}
public static bool AddItemStacked_Prefix(StorageComponent __instance, int itemId, int count)
{
//Run only in MP, if it is not triggered remotly and if this event was triggered manually by an user
if (SimulatedWorld.Initialized && !StorageManager.EventFromServer && !StorageManager.EventFromClient && StorageManager.IsHumanInput && GameMain.data.localPlanet != null)
{
HandleUserInteraction(__instance, new StorageSyncRealtimeChangePacket(__instance.id, StorageSyncRealtimeChangeEvent.AddItemStacked, itemId, count));
}
return(true);
}
public static void OnManualServingContentChange_Postfix(UIEjectorWindow __instance)
{
//Notify about manual bullet inserting / withdrawing change
if (SimulatedWorld.Initialized)
{
StorageComponent storage = (StorageComponent)AccessTools.Field(typeof(UIEjectorWindow), "servingStorage").GetValue(__instance);
LocalPlayer.SendPacketToLocalStar(new EjectorStorageUpdatePacket(__instance.ejectorId, storage.grids[0].count, GameMain.localPlanet?.id ?? -1));
}
}
public static bool TakeItemFromGrid_Prefix(StorageComponent __instance, int gridIndex, ref int itemId, ref int count, out int inc)
{
//Run only in MP, if it is not triggered remotly and if this event was triggered manually by an user
if (Multiplayer.IsActive && !Multiplayer.Session.Storage.IsIncomingRequest && Multiplayer.Session.Storage.IsHumanInput && GameMain.data.localPlanet != null)
{
HandleUserInteraction(__instance, new StorageSyncRealtimeChangePacket(__instance.id, StorageSyncRealtimeChangeEvent.TakeItemFromGrid, gridIndex, itemId, count, 0));
}
inc = 0; // this is what the game does anyways so it should not change the functionality of the method
return(true);
}
void initializeStorage()
{
storage = new StorageComponent("Quatrix HD");
HighScoreData.load(storage);
ColorData.load(storage);
TextureData.load(storage);
}
public static bool StorageComponent_NotifyStorageChange_Prefix(StorageComponent __instance)
{
if (executeNow)
{
return(true);
}
changedStorages.Add(__instance);
return(false);
}
public static bool GPUInstancingManager_RemoveModel_Prefix(StorageComponent __instance, int modelIndex, int modelId, bool setBuffer = true)
{
if (executeNow)
{
return(true);
}
removedModels.Add(Tuple.Create(modelIndex, modelId, setBuffer));
return(false);
}
public static void save(StorageComponent storage)
{
for (int i = 0; i < colors.Count; i++)
{
data.list[i] = colors[i].R;
data.list[i + 7] = colors[i].G;
data.list[i + 14] = colors[i].B;
}
storage.SaveData <byte>(data, "colors.lst");
}
public MechaData(int sandCount, double coreEnergy, double reactorEnergy, StorageComponent inventory, StorageComponent reactorStorage, StorageComponent warpStorage, MechaForge forge)
{
this.SandCount = sandCount;
this.CoreEnergy = coreEnergy;
this.ReactorEnergy = reactorEnergy;
this.ReactorStorage = reactorStorage;
this.WarpStorage = warpStorage;
this.Forge = forge;
this.Inventory = inventory;
this.TechBonuses = new PlayerTechBonuses();
}
public static void OnAssemblerIdChange_Prefix(UIAssemblerWindow __instance)
{
int[] update = new int[__instance.factorySystem.assemblerPool[__instance.assemblerId].served.Length];
StorageComponent assemblerStorage = (StorageComponent)AccessTools.Field(typeof(UIAssemblerWindow), "servingStorage").GetValue(__instance);
for (int i = 0; i < update.Length; i++)
{
update[i] = assemblerStorage.grids[i].count;
}
LocalPlayer.SendPacketToLocalPlanet(new AssemblerUpdateStoragePacket(update, GameMain.data.localPlanet.factoryIndex, __instance.assemblerId));
}
static bool GetStorageIsFullHalf(StorageComponent sc)
{
for (int i = 0; i < sc.size / 2; i++)
{
if (sc.grids[i].itemId == 0 || sc.grids[i].count < sc.grids[i].stackSize)
{
return(false);
}
}
return(true);
}
public static void MyLoadStatic(StorageComponent __instance)
{
if (!storage_is_change)
{
ItemProto[] dataArray = LDB.items.dataArray;
for (int i = 0; i < dataArray.Length; i++)
{
StorageComponent.itemStackCount[dataArray[i].ID] *= storage_multiple.Value;
}
storage_is_change = true;
}
}
public static void save(StorageComponent storage)
{
for (int i = 0; i < highScores.Count; i++)
{
data.list[i] = highScores[i].score;
data.list[i + 10] = highScores[i].level;
data.list[i + 20] = highScores[i].rows;
data.list[i + 30] = highScores[i].time;
}
storage.SaveData <int>(data, "highscores.lst");
}
