public void AddItemInputRule(ItemInputRule itemInputRule)
{
foreach (var inputRule in _itemInputRules)
{
if (inputRule.Item.Compare(itemInputRule.Item))
{
return;
}
}
_itemInputRules.Add(itemInputRule);
MarkDirtyDelayed();
}
public void ReduceItemInputRuleLimit(ItemInputRule itemInputRule)
{
foreach (var inputRule in _itemInputRules)
{
if (inputRule.Item.Compare(itemInputRule.Item))
{
inputRule.MaxInput -= DefaultInputRuleStep;
if (inputRule.MaxInput < DefaultInputRuleStep)
{
inputRule.MaxInput = DefaultInputRuleStep;
}
}
}
MarkDirtyDelayed();
}
public void IncreaseItemInputRuleLimit(ItemInputRule itemInputRule)
{
foreach (var inputRule in _itemInputRules)
{
if (inputRule.Item.Compare(itemInputRule.Item))
{
inputRule.MaxInput += DefaultInputRuleStep;
if (inputRule.MaxInput >= int.MaxValue - DefaultInputRuleStep)
{
inputRule.MaxInput -= DefaultInputRuleStep;
}
}
}
MarkDirtyDelayed();
}
public override void Read(BinaryReader reader, int entityVersion)
{
_machinePower.CurrentPower = reader.ReadSingle();
_inputEnabled = reader.ReadBoolean();
_outputEnabled = reader.ReadBoolean();
var itemInputRulesCount = reader.ReadInt32();
_itemInputRules = new List <ItemInputRule>();
for (int index = 0; index < itemInputRulesCount; index++)
{
var itemInputRule = new ItemInputRule();
itemInputRule.MaxInput = reader.ReadInt32();
itemInputRule.Item = ItemFile.DeserialiseItem(reader);
_itemInputRules.Add(itemInputRule);
}
}
public void RemoveItemInputRule(ItemInputRule itemInputRule)
{
ItemInputRule itemRuletoRemove = null;
foreach (var inputRule in _itemInputRules)
{
if (inputRule.Item.Compare(itemInputRule.Item))
{
itemRuletoRemove = inputRule;
}
}
if (itemRuletoRemove != null)
{
_itemInputRules.Remove(itemRuletoRemove);
}
MarkDirtyDelayed();
}
/*public static bool TakeItems(Player player, QuantumStorageControllerMachine quantumStorageController,
* ItemBase item)
* {
* if (!player.mbIsLocalPlayer)
* {
* NetworkRedraw = true;
* }
*
* if (quantumStorageController.GetItems().Count > 0)
* {
* quantumStorageController.TakeItem(ref item);
* if (item != null)
* {
* Debug.Log((object) ("Removing Item from StorageHopper for " + player.mUserName));
* if (!player.mInventory.AddItem(itemBase))
* {
* if (!quantumStorageController.AddItem(itemBase))
* ItemManager.instance.DropItem(itemBase, player.mnWorldX, player.mnWorldY, player.mnWorldZ,
* Vector3.zero);
* return false;
* }
*
* if (player.mbIsLocalPlayer)
* {
* Color lCol = Color.green;
* if (itemBase.mType == ItemType.ItemCubeStack)
* {
* ItemCubeStack itemCubeStack = itemBase as ItemCubeStack;
* if (CubeHelper.IsGarbage(itemCubeStack.mCubeType))
* lCol = Color.red;
* if (CubeHelper.IsSmeltableOre(itemCubeStack.mCubeType))
* lCol = Color.green;
* }
*
* if (itemBase.mType == ItemType.ItemStack)
* lCol = Color.cyan;
* if (itemBase.mType == ItemType.ItemSingle)
* lCol = Color.white;
* if (itemBase.mType == ItemType.ItemCharge)
* lCol = Color.magenta;
* if (itemBase.mType == ItemType.ItemDurability)
* lCol = Color.yellow;
* if (itemBase.mType == ItemType.ItemLocation)
* lCol = Color.gray;
* FloatingCombatTextManager.instance.QueueText(quantumStorageController.mnX,
* quantumStorageController.mnY + 1L, quantumStorageController.mnZ, 1f,
* player.GetItemName(itemBase), lCol, 1.5f, 64f);
* }
*
* player.mInventory.VerifySuitUpgrades();
* if (!WorldScript.mbIsServer)
* NetworkManager.instance.SendInterfaceCommand(nameof(StorageHopperWindowNew), nameof(TakeItems),
* (string) null, itemBase, (SegmentEntity) quantumStorageController, 0.0f);
* return true;
* }
* }
*
* return false;
* }*/
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
if (!(nic.target is QuantumStorageControllerMachine target))
{
return(null);
}
var command = nic.command;
if (command != null)
{
var dictionary = new Dictionary <string, int>(2);
dictionary.Add("ToggleInput", 1);
dictionary.Add("ToggleOutput", 2);
dictionary.Add("AddItemRule", 3);
dictionary.Add("RemoveItemRule", 4);
dictionary.Add("ReduceItemRule", 5);
dictionary.Add("IncreaseItemRule", 6);
if (dictionary.TryGetValue(command, out var num))
{
switch (num)
{
case 1:
target.ToggleInput();
break;
case 2:
target.ToggleOutput();
break;
case 3:
var itemInputRule = new ItemInputRule();
itemInputRule.Item = nic.itemContext;
itemInputRule.MaxInput = int.Parse(nic.payload);
target.AddItemInputRule(itemInputRule);
break;
case 4:
var itemInputRuleToRemove = new ItemInputRule();
itemInputRuleToRemove.Item = nic.itemContext;
itemInputRuleToRemove.MaxInput = int.Parse(nic.payload);
target.RemoveItemInputRule(itemInputRuleToRemove);
break;
case 5:
var itemInputRuleToReduce = new ItemInputRule();
itemInputRuleToReduce.Item = nic.itemContext;
target.ReduceItemInputRuleLimit(itemInputRuleToReduce);
break;
case 6:
var itemInputRuleToIncrease = new ItemInputRule();
itemInputRuleToIncrease.Item = nic.itemContext;
target.IncreaseItemInputRuleLimit(itemInputRuleToIncrease);
break;
}
}
}
var interfaceResponse = new NetworkInterfaceResponse();
interfaceResponse.entity = target;
interfaceResponse.inventory = player.mInventory;
return(interfaceResponse);
}
public override bool ButtonClicked(string name, SegmentEntity targetEntity)
{
var controller = targetEntity as QuantumStorageControllerMachine;
if (controller == null || !controller.IsOperating())
{
return(false);
}
if (name.Equals(InputStatusButton))
{
controller.ToggleInput();
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"ToggleInput",
null, null, controller, 0.0f);
}
Dirty = true;
return(true);
}
if (name.Equals(OutputStatusButton))
{
controller.ToggleOutput();
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"ToggleOutput",
null, null, controller, 0.0f);
}
Dirty = true;
return(true);
}
if (name.Contains(InputRuleIncreaseButton))
{
int.TryParse(name.Replace(InputRuleIncreaseButton, string.Empty), out var itemSlot);
if (itemSlot == -1)
{
return(false);
}
controller.IncreaseItemInputRuleLimit(controller.GetItemInputRules()[itemSlot]);
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"IncreaseItemRule",
null, controller.GetItemInputRules()[itemSlot].Item, controller, 0.0f);
}
Dirty = true;
return(true);
}
if (name.Contains(InputRuleReduceButton))
{
int.TryParse(name.Replace(InputRuleReduceButton, string.Empty), out var itemSlot);
if (itemSlot == -1)
{
return(false);
}
controller.ReduceItemInputRuleLimit(controller.GetItemInputRules()[itemSlot]);
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"ReduceItemRule",
null, controller.GetItemInputRules()[itemSlot].Item, controller, 0.0f);
}
Dirty = true;
return(true);
}
if (name.Contains(InputRuleRemoveButton))
{
int.TryParse(name.Replace(InputRuleRemoveButton, string.Empty), out var itemSlot);
if (itemSlot == -1)
{
return(false);
}
controller.RemoveItemInputRule(controller.GetItemInputRules()[itemSlot]);
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"RemoveItemRule",
controller.GetItemInputRules()[itemSlot].MaxInput.ToString(), controller.GetItemInputRules()[itemSlot].Item, controller, 0.0f);
}
Redraw(targetEntity);
}
if (name.Equals(InputRuleAddButton))
{
_itemSearch = true;
ItemSearchWindow.SetupUIRules();
Redraw(targetEntity);
return(true);
}
if (ItemSearchWindow.HandleButtonPress(this, name, out var selectedItem))
{
_itemSearch = false;
manager.RedrawWindow();
}
if (selectedItem == null)
{
return(false);
}
else
{
var itemInputRule = new ItemInputRule();
itemInputRule.MaxInput = QuantumStorageControllerMachine.DefaultInputRuleStep;
itemInputRule.Item = selectedItem;
controller.AddItemInputRule(itemInputRule);
if (!WorldScript.mbIsServer)
{
NetworkManager.instance.SendInterfaceCommand(QuantumStorageMod.QuantumStorageControllerWindowKey,
"AddItemRule",
itemInputRule.MaxInput.ToString(), selectedItem, controller, 0.0f);
}
Redraw(targetEntity);
}
return(false);
}
