Merge branch 'HbmMods:master' into master

src/main/java/com/hbm/inventory/gui/GUICalculator.java

@@ -1,23 +1,29 @@
 package com.hbm.inventory.gui;
 
-import com.hbm.lib.RefStrings;
+import com.hbm.util.Tuple;
+
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.gui.GuiTextField;
-import net.minecraft.util.ResourceLocation;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.opengl.GL11;
 
 import java.math.BigDecimal;
 import java.math.MathContext;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
 import java.util.Locale;
 import java.util.Stack;
 
 public class GUICalculator extends GuiScreen {
-	private static final ResourceLocation texture = new ResourceLocation(RefStrings.MODID, "textures/gui/calculator.png");
 	private int xSize = 220;
 	private int ySize = 50;
+	private int borderWidth = 2;
 	private GuiTextField inputField;
 
+	private int selectedHist = -1;
+	private static final int maxHistory = 6;
+	private static Deque<Tuple.Pair<String, Double>> history = new ArrayDeque<>();
 	private String latestResult = "?";
 
 	@Override
@@ -46,8 +52,15 @@ public class GUICalculator extends GuiScreen {
 		String input = inputField.getText().replaceAll("[^\\d+\\-*/^!.()\\sA-Za-z]+", "");
 
 		if (p_73869_1_ == 13 || p_73869_1_ == 10) { // when pressing enter (CR or LF)
+			if (selectedHist != -1) {
+				input = new ArrayList<>(history).get(selectedHist).key;
+				inputField.setText(input);
+				selectedHist = -1;
+			} else {
 				try {
 					double result = evaluateExpression(input);
+					history.addFirst(new Tuple.Pair<String,Double>(input, result));
+					if (history.size() > maxHistory) history.removeLast();
 					String plainStringRepresentation = (new BigDecimal(result, MathContext.DECIMAL64)).toPlainString();
 					GuiScreen.setClipboardString(plainStringRepresentation);
 					inputField.setText(plainStringRepresentation);
@@ -56,6 +69,15 @@ public class GUICalculator extends GuiScreen {
 				} catch (Exception ignored) {}
 				return;
 			}
+		}
+
+		if (p_73869_2_ == 200) { // up arrow
+			selectedHist = Math.max(selectedHist - 1, -1);
+		} else if (p_73869_2_ == 208) { // down arrow
+			selectedHist = Math.min(selectedHist + 1, history.size() - 1);
+		} else {
+			selectedHist = -1;
+		}
 
 		if (input.isEmpty()) {
 			latestResult = "?";
@@ -72,14 +94,27 @@ public class GUICalculator extends GuiScreen {
 		super.drawScreen(mouseX, mouseY, partialTicks);
 
 		GL11.glColor4f(1F, 1F, 1F, 1F);
-		mc.getTextureManager().bindTexture(texture);
 		int x = (width - xSize) / 2;
 		int y = (height - ySize) / 2;
+		int histHeight = (fontRendererObj.FONT_HEIGHT + 2) * maxHistory;
+		int histStart = y + 30 + fontRendererObj.FONT_HEIGHT + 8;
 
-		drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
+		drawRect(x, y, x+xSize, y+ySize+histHeight, 0xFF2d2d2d);
+		drawRect(x+borderWidth, y+borderWidth, x+xSize-borderWidth, y+ySize-borderWidth+histHeight, 0xFF3d3d3d);
+		drawRect(x, histStart - 5, x+xSize, histStart - 3, 0xFF2d2d2d);
 
 		inputField.drawTextBox();
 		fontRendererObj.drawString("=" + latestResult, x + 5, y + 30, -1);
+
+		int i = 0;
+		for (Tuple.Pair<String, Double> prevInput : history) {
+			int hy = y + 50 + (fontRendererObj.FONT_HEIGHT+1)*i;
+			if (i == selectedHist) {
+				drawRect(x + 4, hy - 1, x + 4 + xSize - 9, hy + fontRendererObj.FONT_HEIGHT, 0xFF111111);
+			}
+			fontRendererObj.drawString(prevInput.key + " = " + prevInput.value, x + 5, hy, -1);
+			i++;
+		}
 	}
 
 	/**

src/main/java/com/hbm/uninos/networkproviders/PneumaticNetwork.java

@@ -2,6 +2,7 @@ package com.hbm.uninos.networkproviders;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -67,37 +68,64 @@ public class PneumaticNetwork extends NodeNet {
 		if(sendOrder == SEND_LAST) BobMathUtil.reverseIntArray(sourceSlotAccess);
 		if(sendOrder == SEND_RANDOM) BobMathUtil.shuffleIntArray(sourceSlotAccess);
 
+		ISidedInventory sidedSource = source instanceof ISidedInventory ? (ISidedInventory) source : null;
+		boolean hasItem = false;
+
+		for(int i : sourceSlotAccess) {
+			ItemStack stack = source.getStackInSlot(i);
+			if(stack != null) {
+				if(sidedSource != null && !sidedSource.canExtractItem(i, stack, sourceSide)) continue;
+				boolean match = tube.matchesFilter(stack);
+				if((match && !tube.whitelist) || (!match && tube.whitelist)) continue;
+				hasItem = true;
+				break;
+			}
+		}
+
+		// return early if there arent any items in the source inventory, saves on some cpu usage for idle networks
+		if(!hasItem) return false;
+
 		// for round robin, receivers are ordered by proximity to the source
 		ReceiverComparator comparator = new ReceiverComparator(tube);
 		List<Entry<IInventory, Triplet<ForgeDirection, Long, TileEntityPneumoTube>>> receiverList = new ArrayList(receivers.size());
 		receiverList.addAll(receivers.entrySet());
-		receiverList.sort(comparator);
 
-		int index = nextReceiver % receivers.size();
+		if(receiveOrder == RECEIVE_ROBIN) receiverList.sort(comparator);
-		Entry<IInventory, Triplet<ForgeDirection, Long, TileEntityPneumoTube>> chosenReceiverEntry = null;
+		if(receiveOrder == RECEIVE_RANDOM) Collections.shuffle(receiverList);
-
-		if(receiveOrder == RECEIVE_ROBIN) chosenReceiverEntry = receiverList.get(index);
-		if(receiveOrder == RECEIVE_RANDOM) chosenReceiverEntry = receiverList.get(rand.nextInt(receiverList.size()));
-		
-		if(chosenReceiverEntry == null) return false;
-		
-		IInventory dest = chosenReceiverEntry.getKey();
-		TileEntityPneumoTube endpointTile = chosenReceiverEntry.getValue().getZ();
-		ISidedInventory sidedDest = dest instanceof ISidedInventory ? (ISidedInventory) dest : null;
-		ISidedInventory sidedSource = source instanceof ISidedInventory ? (ISidedInventory) source : null;
 
 		TileEntity tile1 = source instanceof TileEntity ? (TileEntity) source : null;
+
+		int attempts = 0;
+		int maxAttempts = receiverList.size();
+
+		// try all receivers for both modes, in an attempts based system.
+		// instead of bailing out of trying after the first failure (which means you have to wait 0.25 seconds), we just try the next one.
+		while(attempts < maxAttempts) {
+			int index = (receiveOrder == RECEIVE_ROBIN) ? (nextReceiver + attempts) % receiverList.size() : attempts;
+
+			Entry<IInventory, Triplet<ForgeDirection, Long, TileEntityPneumoTube>> candidate = receiverList.get(index);
+
+			if(NodeNet.isBadLink(candidate.getKey())) {
+				receivers.remove(candidate.getKey());
+				attempts++;
+				continue;
+			}
+
+			IInventory dest = candidate.getKey();
+			TileEntityPneumoTube endpointTile = candidate.getValue().getZ();
 			TileEntity tile2 = dest instanceof TileEntity ? (TileEntity) dest : null;
 
 			// range check for our compression level, skip if either source or dest aren't tile entities
 			if(tile1 != null && tile2 != null) {
 				int sq = (tile1.xCoord - tile2.xCoord) * (tile1.xCoord - tile2.xCoord) + (tile1.yCoord - tile2.yCoord) * (tile1.yCoord - tile2.yCoord) + (tile1.zCoord - tile2.zCoord) * (tile1.zCoord - tile2.zCoord);
 				if(sq > maxRange * maxRange) {
-				return false;
+					attempts++;
+					continue;
 				}
 			}
 
-		int destSide = chosenReceiverEntry.getValue().getX().getOpposite().ordinal();
+			ISidedInventory sidedDest = dest instanceof ISidedInventory ? (ISidedInventory) dest : null;
+			int destSide = candidate.getValue().getX().getOpposite().ordinal();
 			int[] destSlotAccess = getSlotAccess(dest, destSide);
 			int itemsLeftToSend = ITEMS_PER_TRANSFER; // not actually individual items, but rather the total "mass", based on max stack size
 			int itemHardCap = dest instanceof TileEntityMachineAutocrafter ? 1 : ITEMS_PER_TRANSFER;
@@ -167,9 +195,12 @@ public class PneumaticNetwork extends NodeNet {
 			if(didSomething) {
 				source.markDirty();
 				dest.markDirty();
+				return true;
 			}
 
-		return didSomething;
+			attempts++;
+		}
+		return false;
 	}
 
 	/** Returns an array of accessible slots from the given side of an IInventory. If it's an ISidedInventory, uses the sided restrictions instead. */