//******************** Network Interface ****************************
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
StorageHopper sh = nic.target as StorageHopper;
switch (nic.command)
{
case InterfaceTogglePermissions:
TogglePermissions(player, sh);
break;
case InterfaceToggleHoover:
ToggleHoover(player, sh);
break;
case InterfaceTakeItems:
TakeItems(player, sh);
break;
case InterfaceStoreItems:
StoreItems(player, sh, nic.itemContext);
break;
}
NetworkInterfaceResponse response = new NetworkInterfaceResponse();
response.entity = sh;
response.inventory = player.mInventory;
return(response);
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
ExtraStorageHoppers_OT storageHopper = nic.target as ExtraStorageHoppers_OT;
string command = nic.command;
switch (command)
{
case "TogglePermissions":
ExtraStorageHopperWindow_OT.TogglePermissions(player, storageHopper);
break;
case "ToggleHoover":
ExtraStorageHopperWindow_OT.ToggleHoover(player, storageHopper);
break;
case "TakeItems":
ExtraStorageHopperWindow_OT.TakeItems(player, storageHopper);
break;
case "StoreItems":
ExtraStorageHopperWindow_OT.StoreItems(player, storageHopper, nic.itemContext);
break;
}
return(new NetworkInterfaceResponse
{
entity = storageHopper,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
MSAccessPort port = nic.target as MSAccessPort;
string key = nic.command;
if (key != null)
{
if (key == InterfaceWithdrawItem)
{
int result;
if (int.TryParse(nic.payload ?? "0", out result))
{
MSAccessPortWindow.WithdrawItem(player, port, nic.itemContext, result);
}
}
else if (key == InterfaceDepositItem)
{
int result;
if (int.TryParse(nic.payload ?? "0", out result))
{
MSAccessPortWindow.DepositItem(player, port, nic.itemContext, result);
}
}
}
return(new NetworkInterfaceResponse()
{
entity = port,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
FreightSystemMonitor monitor = nic.target as FreightSystemMonitor;
string command = nic.command;
if (command != null)
{
if (command == InterfaceNetStatus)
{
int Netindex = 0;
int.TryParse(nic.payload ?? "-1", out Netindex);
SystemMonitorWindow.RequestNetworkStatus(Netindex, player, monitor);
}
else if (command == InterfaceTrackSystems)
{
int tracknetwork = -1;
int station = -1;
int cart = -1;
string[] output = nic.payload.Split(',');
if (output.Length > 2)
{
int.TryParse(output[0] ?? "-1", out tracknetwork);
int.TryParse(output[1] ?? "-1", out station);
int.TryParse(output[2] ?? "-1", out cart);
}
SystemMonitorWindow.RequestTrackNetworks(tracknetwork, station, cart, player, monitor);
}
}
return(new NetworkInterfaceResponse
{
entity = monitor,
inventory = player.mInventory
});
}
//Handle network command function - Must be registered with the UIManager in order to be called properly
//Registering it with the UIManager is best done in the FortressCraftMod class' Register method
//The static function calls are designed to work equivalently on the server and client so that the two remain in sync
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
MyModMachine machine = nic.target as MyModMachine;
string key = nic.command;
if (key != null)
{
if (key == InterfaceMyFunctionItem)
{
MyModMachineWindow.MyFunctionItem(player, machine, nic.itemContext);
}
else if (key == InterfaceMyFunctionString)
{
int data;
//Parse the string data (safely) and send to the appropriate function
if (int.TryParse(nic.payload ?? "0", out data))
{
MyModMachineWindow.MyFunctionString(player, machine, data);
}
}
}
return(new NetworkInterfaceResponse()
{
entity = machine,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
ExtraStorageHoppers hopper = nic.target as ExtraStorageHoppers;
string command = nic.command;
if (command != null)
{
string text = command;
switch (text)
{
case "SetAddRemove":
ExtraStorageHopperWindowNew.SetPermissions(player, hopper, eHopperPermissions.AddAndRemove);
break;
case "SetAddOnly":
ExtraStorageHopperWindowNew.SetPermissions(player, hopper, eHopperPermissions.AddOnly);
break;
case "SetRemoveOnly":
ExtraStorageHopperWindowNew.SetPermissions(player, hopper, eHopperPermissions.RemoveOnly);
break;
case "SetLocked":
ExtraStorageHopperWindowNew.SetPermissions(player, hopper, eHopperPermissions.Locked);
break;
case "ToggleHoover":
ExtraStorageHopperWindowNew.ToggleHoover(player, hopper);
break;
case "ToggleShare":
ExtraStorageHopperWindowNew.ToggleShare(player, hopper);
break;
case "TakeItems":
ExtraStorageHopperWindowNew.TakeItems(player, hopper, nic.itemContext);
break;
case "StoreItems":
ExtraStorageHopperWindowNew.StoreItems(player, hopper, nic.itemContext);
break;
case "DebugMode":
ExtraStorageHopperWindowNew.DebugMode(player, hopper);
break;
case "SetExemplar":
ExtraStorageHopperWindowNew.SetNewExamplar(player, hopper, nic.itemContext);
break;
}
}
return(new NetworkInterfaceResponse
{
entity = hopper,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
QuantumOutputPortMachine target = nic.target as QuantumOutputPortMachine;
switch (nic.command)
{
case "SetExemplar":
QuantumOutputPortWindow.SetExemplar(player, target, nic.itemContext);
break;
}
NetworkInterfaceResponse interfaceResponse = new NetworkInterfaceResponse();
interfaceResponse.entity = (SegmentEntity)target;
interfaceResponse.inventory = player.mInventory;
return(interfaceResponse);
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
MSManufacturer port = nic.target as MSManufacturer;
string key = nic.command;
if (key != null)
{
if (key == InterfaceSetItemToAssemble)
{
MSManufacturerWindow.SetItemToAssemble(player, port, nic.itemContext);
}
}
return(new NetworkInterfaceResponse()
{
entity = (SegmentEntity)port,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
Mk2Excavator machine = nic.target as Mk2Excavator;
string key = nic.command;
if (key != null)
{
int data;
if (key == "AlterHeight")
{
int.TryParse(nic.payload ?? "1", out data);
Mk2ExcavatorWindow.AlterHeight(machine, data);
}
else if (key == "AlterRadius")
{
int.TryParse(nic.payload ?? "1", out data);
Mk2ExcavatorWindow.AlterRadius(machine, data);
}
else if (key == "AlterDigState")
{
Mk2ExcavatorWindow.AlterDigState(machine, nic.payload);
}
else if (key == "AlterDropState")
{
Mk2ExcavatorWindow.AlterDropState(machine, nic.payload);
}
else if (key == "SuperOPMode")
{
int.TryParse(nic.payload ?? "1", out data);
Mk2ExcavatorWindow.SuperOPMode(machine, data);
}
else if (key == "MutePews")
{
int.TryParse(nic.payload ?? "1", out data);
Mk2ExcavatorWindow.MutePews(machine, data);
}
}
return(new NetworkInterfaceResponse()
{
entity = (SegmentEntity)machine,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
FreightTrackJunction junction = nic.target as FreightTrackJunction;
string command = nic.command;
if (command != null)
{
if (command == InterfaceResetJunction)
{
TrackJunctionWindow.ResetJunction(junction);
}
}
return(new NetworkInterfaceResponse
{
entity = junction,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
TourCartStation station = nic.target as TourCartStation;
string command = nic.command;
if (command != null)
{
if (command == InterfaceStationName)
{
TourStationWindow.SetStationName(station, nic.payload);
}
}
return(new NetworkInterfaceResponse
{
entity = station,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
FreightSystemMonitor monitor = nic.target as FreightSystemMonitor;
string command = nic.command;
if (command != null)
{
if (command == InterfaceNetStatus)
{
int Netindex = 0;
int.TryParse(nic.payload ?? "-1", out Netindex);
SystemMonitorWindow.RequestNetworkStatus(Netindex, player, monitor);
}
}
return(new NetworkInterfaceResponse
{
entity = monitor,
inventory = player.mInventory
});
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
//NIC = NetworkInterfaceCommand
ExtraStorageHoppers storageHopper = nic.target as ExtraStorageHoppers;
string command = nic.command;
switch (command)
{
case "TogglePermissions":
ExtraStorageHopperWindow.TogglePermissions(player, storageHopper);
break;
case "ToggleHoover":
ExtraStorageHopperWindow.ToggleHoover(player, storageHopper);
break;
case "TakeItems":
ExtraStorageHopperWindow.TakeItems(player, storageHopper);
break;
case "StoreItems":
ExtraStorageHopperWindow.StoreItems(player, storageHopper, nic.itemContext);
break;
case "DebugMode":
ExtraStorageHopperWindow.DebugMode(player, storageHopper);
break;
case "SetExemplar":
ExtraStorageHopperWindow.SetNewExamplar(player, storageHopper, nic.itemContext);
break;
}
return(new NetworkInterfaceResponse
{
entity = storageHopper,
inventory = player.mInventory
});
}
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("TakeItem", 1);
dictionary.Add("StoreItem", 2);
if (dictionary.TryGetValue(command, out var num))
{
switch (num)
{
case 1:
TakeItem(player, target, nic.itemContext);
break;
case 2:
StoreItem(player, target, nic.itemContext);
break;
}
}
}
var interfaceResponse = new NetworkInterfaceResponse();
interfaceResponse.entity = target;
interfaceResponse.inventory = player.mInventory;
return(interfaceResponse);
}
public static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
int quarrylevel;
int.TryParse(nic.payload ?? "1", out quarrylevel);
AdvancedQuarrys lMk123Quarry = null;
Mk4Quarry lMk4Quarry = null;
Mk5Quarry lMk5Quarry = null;
SegmentEntity machine = null;
switch (quarrylevel)
{
case 123: lMk123Quarry = nic.target as AdvancedQuarrys;
machine = (SegmentEntity)lMk123Quarry;
break;
case 4: lMk4Quarry = nic.target as Mk4Quarry;
machine = (SegmentEntity)lMk4Quarry;
break;
case 5: lMk5Quarry = nic.target as Mk5Quarry;
machine = (SegmentEntity)lMk5Quarry;
break;
}
string key = nic.command;
if (key != null)
{
if (key == "ConfirmMk123")
{
FlexibleQuarryWindow.ConfirmMk123(lMk123Quarry, quarrylevel);
}
else if (key == "ResetMk123")
{
FlexibleQuarryWindow.ResetMk123(lMk123Quarry, quarrylevel);
}
else if (key == "ConfirmMk4")
{
FlexibleQuarryWindow.ConfirmMk4(lMk4Quarry, quarrylevel);
}
else if (key == "Mk4DestroyOre")
{
FlexibleQuarryWindow.Mk4DestroyOre(lMk4Quarry, quarrylevel);
}
else if (key == "ResetMk4")
{
FlexibleQuarryWindow.ResetMk4(lMk4Quarry, quarrylevel);
}
else if (key == "ConfirmMk5")
{
FlexibleQuarryWindow.ConfirmMk5(lMk5Quarry, quarrylevel);
}
else if (key == "Mk5DestroyOre")
{
FlexibleQuarryWindow.Mk5DestroyOre(lMk5Quarry, quarrylevel);
}
else if (key == "ResetMk5")
{
FlexibleQuarryWindow.ResetMk5(lMk5Quarry, quarrylevel);
}
else if (key == "RotateMk5")
{
FlexibleQuarryWindow.RotateMk5(lMk5Quarry, quarrylevel);
}
}
return(new NetworkInterfaceResponse()
{
entity = (SegmentEntity)machine,
inventory = player.mInventory
});
}
/*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 static NetworkInterfaceResponse HandleNetworkCommand(Player player, NetworkInterfaceCommand nic)
{
FreightCartStation station = nic.target as FreightCartStation;
string command = nic.command;
if (command != null)
{
if (command == InterfaceRemoveReg)
{
FreightCartWindow.RemoveRegistry(station, nic.itemContext);
}
else if (command == InterfaceSetLowStock)
{
int stock = -1;
int.TryParse(nic.payload ?? "-1", out stock);
FreightCartWindow.SetLowStock(station, nic.itemContext, stock);
}
else if (command == InterfaceSetHighStock)
{
int stock = -1;
int.TryParse(nic.payload ?? "-1", out stock);
FreightCartWindow.SetHighStock(station, nic.itemContext, stock);
}
else if (command == InterfaceAssignedCarts)
{
int carts = 0;
int.TryParse(nic.payload ?? "-1", out carts);
FreightCartWindow.SetCartAssignment(station, carts);
}
else if (command == InterfaceCartTier)
{
int carttier = 0;
int.TryParse(nic.payload ?? "2", out carttier);
FreightCartWindow.ToggleCartTier(station, carttier);
}
else if (command == InterfaceHopperHigh)
{
int offer = -1;
int.TryParse(nic.payload ?? "-1", out offer);
FreightCartWindow.SetHopperOffer(station, offer);
}
else if (command == InterfaceHopperLow)
{
int request = -1;
int.TryParse(nic.payload ?? "-1", out request);
FreightCartWindow.SetHopperRequest(station, request);
}
else if (command == InterfaceToggleLoad)
{
FreightCartWindow.ToggleLoadStatus(station, nic.payload);
}
else if (command == InterfaceToggleOffer)
{
FreightCartWindow.ToggleOfferAll(station, nic.payload);
}
else if (command == InterfaceAddReg)
{
FreightCartWindow.AddRegistry(station, nic.itemContext);
}
else if (command == InterfaceSetNetwork)
{
FreightCartWindow.SetNetwork(station, nic.payload);
}
else if (command == InterfaceSetName)
{
FreightCartWindow.SetStationName(station, nic.payload);
}
else if (command == InterfaceSetInventoryName)
{
FreightCartWindow.NameInventory(station, nic.payload);
}
else if (command == InterfaceCopyFreight)
{
FreightCartWindow.CopyFreight(station);
}
else if (command == InterfacePasteFreight)
{
FreightCartWindow.PasteFreight(station);
}
else if (command == InterfaceHopperOffer)
{
FreightCartWindow.SetHopperOfferItem(station, nic.itemContext);
}
else if (command == InterfaceHopperRequest)
{
FreightCartWindow.SetHopperRequestItem(station, nic.itemContext);
}
}
return(new NetworkInterfaceResponse
{
entity = station,
inventory = player.mInventory
});
}
