Merge pull request #2002 from EverMine/master

Add missing adding to neiShredderRecipes in CompatRecipeRegistry

src/main/java/com/hbm/inventory/recipes/ShredderRecipes.java

@@ -422,7 +422,7 @@ public class ShredderRecipes extends SerializableRecipe {
 
 		//convert the map only once to save on processing power (might be more ram intensive but that can't be THAT bad, right?)
 		if(neiShredderRecipes == null)
-			neiShredderRecipes = new HashMap(shredderRecipes);
+			neiShredderRecipes = new HashMap<>(shredderRecipes);
 
 		return neiShredderRecipes;
 	}

src/main/java/com/hbm/util/CompatRecipeRegistry.java

@@ -48,20 +48,22 @@ public class CompatRecipeRegistry {
 	public static void registerPress(StampType stamp, AStack input, ItemStack output) {
 		PressRecipes.recipes.put(new Pair(input, stamp), output);
 	}
-	
+
 	/** Same loose rules as BlastFurnaceRecipes, valid inputs are Items, Blocks, ItemStacks, ComparableStacks, Strings (for oredict) and DictFrames */
 	public static void registerBlastFurnace(Object[] inputs, ItemStack output) {
 		if(inputs.length != 2) return;
 		BlastFurnaceRecipes.addRecipe(inputs[0], inputs[1], output);
 	}
-	
+
 	public static void registerShredder(AStack input, ItemStack output) {
 		for(ItemStack allItems : input.extractForNEI()) {
 			ComparableStack comp = new ComparableStack(allItems);
 			ShredderRecipes.shredderRecipes.put(comp, output);
+			if (ShredderRecipes.neiShredderRecipes != null)
+				ShredderRecipes.neiShredderRecipes.put(comp, output);
 		}
 	}
-	
+
 	/** Items should strictly be categorized as pcb, topping or solder. An item that is used as a topping in one recipe should not be a pcb in another.
 	 * This is because the soldering station's item IO will automatically place items based on this category, and having items in more than one category would break it. */
 	public static void registerSoldering(ItemStack output, int time, long power, FluidStack fluid, AStack[] toppings, AStack[] pcb, AStack[] solder) {
@@ -77,29 +79,29 @@ public class CompatRecipeRegistry {
 		if(outputFluids != null) recipe.outputFluids(copyFirst(outputFluids, 2));
 		ChemplantRecipes.recipes.add(recipe);
 	}
-	
+
 	/** Either solid or liquid output can be null */
 	public static void registerCombination(AStack input, ItemStack output, FluidStack fluid) {
 		if(output == null && fluid == null) return;
 		Object o = input instanceof OreDictStack ? ((OreDictStack) input).name : input;
 		CombinationRecipes.recipes.put(o, new Pair(output, fluid));
 	}
-	
+
 	/** Crucible recipes need unique IDs, game will crash when an ID collision is detected! */
 	public static void registerCrucible(int index, String name, int frequency, ItemStack icon, MaterialStack[] input, MaterialStack[] output) {
 		CrucibleRecipe recipe = new CrucibleRecipe(index, name, frequency, icon).inputs(input).outputs(output);
 		CrucibleRecipes.recipes.add(recipe);
 	}
-	
+
 	public static void registerCentrifuge(AStack input, ItemStack[] outputs) {
 		CentrifugeRecipes.recipes.put(input, copyFirst(outputs, 4));
 	}
-	
+
 	public static void registerCrystallizer(AStack input, ItemStack output, int time, float productivity, FluidStack fluid) {
 		CrystallizerRecipe recipe = new CrystallizerRecipe(output, time).prod(productivity);
 		CrystallizerRecipes.registerRecipe(input instanceof OreDictStack ? ((OreDictStack) input).name : input, recipe, fluid);
 	}
-	
+
 	/** Fractions always use 100mB of input fluid per operation. None of the outputs can be null. */
 	public static void registerFraction(FluidType input, FluidStack[] output) {
 		if(output.length != 2) return;
@@ -111,7 +113,7 @@ public class CompatRecipeRegistry {
 		if(output.length != 2) return;
 		CrackingRecipes.cracking.put(input, new Pair(output[0], output[1]));
 	}
-	
+
 	/** Reforming always uses 100mB of input fluid per operation. None of the outputs can be null. */
 	public static void registerReforming(FluidType input, FluidStack[] output) {
 		output = copyFirst(output, 3);
@@ -125,87 +127,87 @@ public class CompatRecipeRegistry {
 		if(output.length < 2) return;
 		HydrotreatingRecipes.recipes.put(input, new Triplet(hydrogen, output[0], output[1]));
 	}
-	
+
 	public static void registerLiquefaction(AStack input, FluidStack output) {
 		LiquefactionRecipes.recipes.put(input instanceof OreDictStack ? ((OreDictStack) input).name : input, output);
 	}
-	
+
 	public static void registerSolidifying(FluidStack input, ItemStack output) {
 		SolidificationRecipes.recipes.put(input.type, new Pair(input.fill, output));
 	}
-	
+
 	public static void registerCoker(FluidStack input, ItemStack output, FluidStack fluid) {
 		CokerRecipes.recipes.put(input.type, new Triplet(input.fill, output, fluid));
 	}
-	
+
 	/** Registers a coker recipe based on the standardized fluid to coke values */
 	public static void registerCokerAuto(FluidType input, FluidType output) {
 		CokerRecipes.registerAuto(input, output);
 	}
-	
+
 	public static void registerPyro(FluidStack inputFluid, AStack inputItem, FluidStack outputFluid, ItemStack outputItem, int duration) {
 		PyroOvenRecipes.recipes.add(new PyroOvenRecipe(duration).in(inputFluid).in(inputItem).out(outputFluid).out(outputItem));
 	}
-	
+
 	/** Registers a pyro oven recipe based on the standardized fluid to solid fuel values */
 	public static void registerPyroAuto(FluidType input) {
 		PyroOvenRecipes.registerSFAuto(input);
 	}
-	
+
 	/** Breeding reactor does not handle OreDictStacks */
 	public static void registerBreeder(ComparableStack input, ItemStack output, int flux) {
 		BreederRecipes.recipes.put(input, new BreederRecipe(output, flux));
 	}
-	
+
 	public static void registerCyclotron(ComparableStack box, AStack target, ItemStack output, int antimatter) {
 		CyclotronRecipes.recipes.put(new Pair(box, target), new Pair(output, antimatter));
 	}
-	
+
 	/** Fuel pools do not handle OreDictStacks */
 	public static void registerFuelPool(ComparableStack input, ItemStack output) {
 		FuelPoolRecipes.recipes.put(input, output);
 	}
-	
+
 	//TBI mixer
-	
+
 	public static void registerOutgasser(AStack input, ItemStack output, FluidStack fluid) {
 		OutgasserRecipes.recipes.put(input, new Pair(output, fluid));
 	}
-	
+
 	public static void registerCompressor(FluidStack input, FluidStack output, int time) {
 		CompressorRecipes.recipes.put(new Pair(input.type, input.pressure), new CompressorRecipe(input.fill, output, time));
 	}
-	
+
 	/** Byproduct array can be null, fluid output length must be 2 */
 	public static void registerElectrolyzerFluid(FluidStack input, FluidStack[] output, ItemStack[] byproduct, int time) {
 		output = copyFirst(output, 2);
 		if(output.length < 2) return;
 		if(byproduct != null) byproduct = copyFirst(byproduct, 3);
-		
+
 		ElectrolyserFluidRecipes.recipes.put(input.type, new ElectrolysisRecipe(input.fill, output[0], output[1], time, byproduct));
 	}
-	
+
 	/** Output array length must be 2, outputs can be null. Byproduct array can be null. */
 	public static void registerElectrolyzerMetal(AStack input, MaterialStack[] output, ItemStack[] byproduct, int time) {
 		output = copyFirst(output, 2);
 		if(byproduct != null) byproduct = copyFirst(byproduct, 6);
-		
+
 		ElectrolyserMetalRecipes.recipes.put(input, new ElectrolysisMetalRecipe(output[0], output[1], time, byproduct));
 	}
-	
+
 	public static void registerArcWelder(ItemStack output, int time, long power, FluidStack fluid, AStack[] inputs) {
 		ArcWelderRecipes.recipes.add(new ArcWelderRecipe(output, time, power, fluid, copyFirst(inputs, 3)));
 	}
-	
+
 	public static void registerRotaryFurnace(MaterialStack output, int time, int steam, FluidStack fluid, AStack[] inputs) {
 		RotaryFurnaceRecipes.recipes.add(new RotaryFurnaceRecipe(output, time, steam, fluid, copyFirst(inputs, 3)));
 	}
-	
+
 	/** Particles will always perform 8 recipes */
 	public static void registerExposureChamber(AStack particle, AStack input, ItemStack output) {
 		ExposureChamberRecipes.recipes.add(new ExposureChamberRecipe(particle, input, output));
 	}
-	
+
 	/** Input needs two AStacks, output can take 1-2 ItemStacks. If the same recipe with different
 	 * momentum should yield different results, register the lower momentum recipes first. */
 	public static void registerParticleAccelerator(AStack[] input, int momentum, ItemStack[] output) {
@@ -215,47 +217,47 @@ public class CompatRecipeRegistry {
 		if(output.length < 1) return;
 		ParticleAcceleratorRecipes.recipes.add(new ParticleAcceleratorRecipe(input[0], input[1], momentum, output[0], output.length > 1 ? output[1] : null));
 	}
-	
+
 	public static void registerAmmoPress(ItemStack output, AStack[] input) {
 		if(input.length != 9) return;
 		AmmoPressRecipes.recipes.add(new AmmoPressRecipe(output, input));
 	}
-	
+
 	public static void registerAssembler(ItemStack output, AStack[] input, int time) {
 		AssemblerRecipes.makeRecipe(new ComparableStack(output), copyFirst(input, 12), time);
 	}
-	
+
 	/** Registers an assembler recipe but with the template only being obtainable via the specified folders */
 	public static void registerAssembler(ItemStack output, AStack[] input, int time, Item... folder) {
 		AssemblerRecipes.makeRecipe(new ComparableStack(output), copyFirst(input, 12), time, folder);
 	}
-	
+
 	public static void registerAnvilConstruction(AStack[] input, AnvilOutput[] output, int tier, int overlayIndex) {
 		AnvilRecipes.constructionRecipes.add(new AnvilConstructionRecipe(input, output).setTier(tier).setOverlay(EnumUtil.grabEnumSafely(OverlayType.class, overlayIndex)));
 	}
-	
+
 	public static void registerAnvilConstruction(AStack[] input, AnvilOutput[] output, int tierLower, int tierUpper, int overlayIndex) {
 		AnvilRecipes.constructionRecipes.add(new AnvilConstructionRecipe(input, output).setTierRange(tierLower, tierUpper).setOverlay(EnumUtil.grabEnumSafely(OverlayType.class, overlayIndex)));
 	}
-	
+
 	public static void registerPedestal(ItemStack output, AStack[] input) {
 		registerPedestal(output, input, 0);
 	}
-	
+
 	public static void registerPedestal(ItemStack output, AStack[] input, int condition) {
 		input = copyFirst(input, 9);
 		if(input.length < 9) return;
 		PedestalRecipes.recipes.add(new PedestalRecipe(output, input).extra(EnumUtil.grabEnumSafely(PedestalExtraCondition.class, condition)));
 	}
-	
+
 	/** Either output or fluid can be null */
 	public static void registerArcFurnace(AStack input, ItemStack output, MaterialStack fluid) {
 		if(output == null && fluid == null) return;
 		ArcFurnaceRecipes.recipeList.add(new Pair(input, new ArcFurnaceRecipe().solid(output).fluid(fluid)));
 	}
-	
+
 	/////////////////////////////////////////////////////////////////////////////////////////
-	
+
 	/** If the supplied array exceeds the specified length, creates a copy and trunkates the array. Otherwise, returns the original array */
 	private static <T> T[] copyFirst(T[] array, int amount) {
 		if(array.length <= amount) return array;