aboutsummaryrefslogtreecommitdiff
path: root/src/Java/gtPlusPlus/core/util
diff options
context:
space:
mode:
Diffstat (limited to 'src/Java/gtPlusPlus/core/util')
-rw-r--r--src/Java/gtPlusPlus/core/util/Utils.java28
-rw-r--r--src/Java/gtPlusPlus/core/util/math/MathUtils.java270
-rw-r--r--src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java13
-rw-r--r--src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java270
4 files changed, 469 insertions, 112 deletions
diff --git a/src/Java/gtPlusPlus/core/util/Utils.java b/src/Java/gtPlusPlus/core/util/Utils.java
index c600e48f3c..624ed35b60 100644
--- a/src/Java/gtPlusPlus/core/util/Utils.java
+++ b/src/Java/gtPlusPlus/core/util/Utils.java
@@ -374,7 +374,7 @@ public class Utils {
/*
* http://javadevnotes.com/java-left-pad-string-with-zeros-examples
*/
- public static String leftPadWithZeroes(final String originalString, final int length) {
+ public static String padWithZerosLefts(final String originalString, final int length) {
final StringBuilder sb = new StringBuilder();
while ((sb.length() + originalString.length()) < length) {
sb.append('0');
@@ -383,6 +383,19 @@ public class Utils {
final String paddedString = sb.toString();
return paddedString;
}
+
+ public static String padWithZerosRight(final int value, final int length) {
+ String originalString = String.valueOf(value);
+ final StringBuilder sb = new StringBuilder();
+ while ((sb.length() + originalString.length()) < length) {
+ sb.append('0');
+ }
+ //sb.append(originalString);
+ if (sb.length() > 0)
+ originalString = (originalString + sb.toString());
+ final String paddedString = sb.toString();
+ return originalString;
+ }
/*
* Original Code by Chandana Napagoda -
@@ -429,17 +442,20 @@ public class Utils {
if (hexAsStringOrInt.getClass() == String.class) {
if (((String) hexAsStringOrInt).length() != 6) {
- final String temp = leftPadWithZeroes((String) hexAsStringOrInt, 6);
+ final String temp = padWithZerosLefts((String) hexAsStringOrInt, 6);
result = temp;
}
result = hexChar + hexAsStringOrInt;
return result;
- } else if (hexAsStringOrInt.getClass() == Integer.class) {
- if (((String) hexAsStringOrInt).length() != 6) {
- final String temp = leftPadWithZeroes((String) hexAsStringOrInt, 6);
+ } else if (hexAsStringOrInt.getClass() == Integer.class || hexAsStringOrInt.getClass() == int.class) {
+ String aa = String.valueOf(hexAsStringOrInt);
+ if (aa.length() != 6) {
+ final String temp = padWithZerosLefts(aa, 6);
result = temp;
}
- result = hexChar + String.valueOf(hexAsStringOrInt);
+ else {
+ result = hexChar + String.valueOf(hexAsStringOrInt);
+ }
return result;
} else {
return null;
diff --git a/src/Java/gtPlusPlus/core/util/math/MathUtils.java b/src/Java/gtPlusPlus/core/util/math/MathUtils.java
index 48d56b3aa8..40ac23a1b8 100644
--- a/src/Java/gtPlusPlus/core/util/math/MathUtils.java
+++ b/src/Java/gtPlusPlus/core/util/math/MathUtils.java
@@ -127,7 +127,7 @@ public class MathUtils {
public static double findPercentage(final double current, final double max){
return Math.round(((current / max) * 100) * 100.00) / 100.00;
}
-
+
public static int findPercentageOfInt(long input, float percentage){
return (int)(input*(percentage/100.0f));
}
@@ -185,20 +185,20 @@ public class MathUtils {
}
return result;
}
-
-
+
+
//Smooth Rounding Function
- /**
- * Returns a long.
- * The returned number is d rounded to the nearest flat long.
- * Supports Doubles as input.
- *
- * @param current Current value.
- * @return long Rounded value.
- */
- public static long roundToClosestLong(final double d) {
- return (long) (Math.round(d * 2) / 2.0);
- }
+ /**
+ * Returns a long.
+ * The returned number is d rounded to the nearest flat long.
+ * Supports Doubles as input.
+ *
+ * @param current Current value.
+ * @return long Rounded value.
+ */
+ public static long roundToClosestLong(final double d) {
+ return (long) (Math.round(d * 2) / 2.0);
+ }
/**
@@ -360,11 +360,11 @@ public class MathUtils {
public static byte safeByte(long number){
return number>Byte.MAX_VALUE ? Byte.MAX_VALUE :(byte)number;
}
-
+
public static short safeShort(long number){
return number>Short.MAX_VALUE ? Short.MAX_VALUE :(short)number;
}
-
+
public static int safeInt(long number, int margin){
return number>Integer.MAX_VALUE-margin ? Integer.MAX_VALUE-margin :(int)number;
}
@@ -381,65 +381,74 @@ public class MathUtils {
mLargeChanceArray[g] = mValues[mValueSelection];
}
return mLargeChanceArray[randInt(0, mLargeChanceArray.length-1)];
-
+
}
-
-
+
+
/*
* Averages
*/
-
- public static byte getByteAverage(AutoMap aDataSet) {
+
+ public static byte getByteAverage(AutoMap<Byte> aDataSet) {
byte[] aNewSet = new byte[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (byte) aDataSet.get(u);
+ byte b = getSafeByte(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getByteAverage(aNewSet);
}
-
- public static short getShortAverage(AutoMap aDataSet) {
+
+ public static short getShortAverage(AutoMap<Short> aDataSet) {
short[] aNewSet = new short[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (short) aDataSet.get(u);
+ short b = getSafeShort(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getShortAverage(aNewSet);
}
-
- public static int getIntAverage(AutoMap aDataSet) {
+
+ public static int getIntAverage(AutoMap<Integer> aDataSet) {
int[] aNewSet = new int[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (int) aDataSet.get(u);
+ int b = getSafeInt(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getIntAverage(aNewSet);
}
-
- public static float getFloatAverage(AutoMap aDataSet) {
+
+ public static float getFloatAverage(AutoMap<Float> aDataSet) {
float[] aNewSet = new float[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (float) aDataSet.get(u);
+ float b = getSafeFloat(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getFloatAverage(aNewSet);
}
-
- public static long getLongAverage(AutoMap aDataSet) {
+
+ public static long getLongAverage(AutoMap<Long> aDataSet) {
long[] aNewSet = new long[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (long) aDataSet.get(u);
+ long b = getSafeLong(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getLongAverage(aNewSet);
}
-
- public static double getDoubleAverage(AutoMap aDataSet) {
+
+ public static double getDoubleAverage(AutoMap<Double> aDataSet) {
double[] aNewSet = new double[aDataSet.size()];
for (int u=0;u<aDataSet.size();u++) {
- aNewSet[u] = (double) aDataSet.get(u);
+ double b = getSafeDouble(aDataSet.get(u));
+ aNewSet[u] = b;
}
return getDoubleAverage(aNewSet);
}
-
-
-
+
+
+
public static byte getByteAverage(byte[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
byte total = 0;
for (byte i : aDataSet) {
@@ -448,17 +457,26 @@ public class MathUtils {
byte result = safeByte(total/divisor);
return result;
}
-
+
public static short getShortAverage(short[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
+ Logger.INFO("Calculating Average Short. Divisor: "+divisor);
short total = 0;
for (short i : aDataSet) {
+ Logger.INFO("Adding "+i);
total += i;
}
- short result = safeShort(total/divisor);
+ short result = safeShort((total/divisor));
+ Logger.INFO("Average: "+result);
return result;
}
public static int getIntAverage(int[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
int total = 0;
for (int i : aDataSet) {
@@ -468,6 +486,9 @@ public class MathUtils {
return result;
}
public static float getFloatAverage(float[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
float total = 0;
for (float i : aDataSet) {
@@ -477,6 +498,9 @@ public class MathUtils {
return result;
}
public static long getLongAverage(long[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
long total = 0;
for (long i : aDataSet) {
@@ -486,6 +510,9 @@ public class MathUtils {
return result;
}
public static double getDoubleAverage(double[] aDataSet) {
+ if (aDataSet.length <= 0) {
+ return 0;
+ }
int divisor = aDataSet.length;
double total = 0;
for (double i : aDataSet) {
@@ -495,4 +522,163 @@ public class MathUtils {
return result;
}
+ public static int howManyPlaces(int aValueForGen) {
+ if (aValueForGen < 0) {
+ aValueForGen = makeNegative(aValueForGen);
+ }
+ String a = String.valueOf(aValueForGen);
+ return a.length();
+ }
+
+ /**
+ * Inverts the value, making Positives into Negatives and vice versa.
+ * @param aPositive - An int value, either positive or negative.
+ * @return - Inverted int Value.
+ */
+ public static int makeNegative(int aPositive) {
+ if (aPositive > 0) {
+ return -aPositive;
+ }
+ else if (aPositive < 0) {
+ return +aPositive;
+ }
+ else {
+ return 0;
+ }
+ }
+
+ public static <V> V safeCast(Object aNumberType) {
+ long a1;
+ double a2;
+ a1 = Long.parseLong(aNumberType.toString());
+ a2 = Double.parseDouble(aNumberType.toString());
+
+ if ((aNumberType.getClass() == byte.class) || (aNumberType instanceof Byte)){
+ if (a1 >= Byte.MIN_VALUE && a1 <= Byte.MAX_VALUE) {
+ String s = ""+a1;
+ Byte s1 = Byte.valueOf(s);
+ return (V) s1;
+ }
+ }
+ else if ((aNumberType.getClass() == short.class) || (aNumberType instanceof Short)){
+ if (a1 >= Short.MIN_VALUE && a1 <= Short.MAX_VALUE) {
+ String s = ""+a1;
+ Short s1 = Short.valueOf(s);
+ return (V) s1;
+
+ }
+ }
+ else if ((aNumberType.getClass() == int.class) || (aNumberType instanceof Integer)){
+ if (a1 >= Integer.MIN_VALUE && a1 <= Integer.MAX_VALUE) {
+ String s = ""+a1;
+ Integer s1 = Integer.valueOf(s);
+ return (V) s1;
+
+ }
+ }
+ else if ((aNumberType.getClass() == long.class) || (aNumberType instanceof Long)){
+ if (a1 >= Long.MIN_VALUE && a1 <= Long.MAX_VALUE) {
+ String s = ""+a1;
+ Long s1 = Long.valueOf(s);
+ return (V) s1;
+ }
+ }
+ else if ((aNumberType.getClass() == float.class) || (aNumberType instanceof Float)){
+ if (a2 >= Float.MIN_VALUE && a2 <= Float.MAX_VALUE) {
+ String s = ""+a1;
+ Float s1 = Float.valueOf(s);
+ return (V) s1;
+
+ }
+ }
+ else if ((aNumberType.getClass() == double.class) || (aNumberType instanceof Double)){
+ if (a2 >= Double.MIN_VALUE && a2 <= Double.MAX_VALUE) {
+ String s = ""+a1;
+ Double s1 = Double.valueOf(s);
+ return (V) s1;
+
+ }
+ }
+
+ Integer o = 0;
+ return (V) o;
+
+ }
+
+ public static byte getSafeByte(Byte b) {
+ Byte a = safeCast(b);
+ return a.byteValue();
+ }
+
+ public static short getSafeShort(Short b) {
+ Short a = safeCast(b);
+ return a.shortValue();
+ }
+
+ public static int getSafeInt(Integer b) {
+ Integer a = safeCast(b);
+ return a.intValue();
+ }
+
+ public static long getSafeLong(Long b) {
+ Long a = safeCast(b);
+ return a.longValue();
+ }
+
+ public static float getSafeFloat(Float b) {
+ Float a = safeCast(b);
+ return a.floatValue();
+ }
+
+ public static double getSafeDouble(Double b) {
+ Double a = safeCast(b);
+ return a.doubleValue();
+ }
+
+
+ public static long safeCast_IntToLong(int o) {
+ long i = o;
+ return i;
+ }
+
+ public static int safeCast_LongToInt(long o) {
+ if (o > Integer.MAX_VALUE) {
+ return Integer.MAX_VALUE;
+ }
+ else {
+ int i = (int) o;
+ return i;
+ }
+ }
+
+ public static short safeCast_IntToShort(int o) {
+ if (o > Short.MAX_VALUE) {
+ return Short.MAX_VALUE;
+ }
+ else {
+ short i = (short) o;
+ return i;
+ }
+ }
+
+ public static int safeCast_ShortToInt(short o) {
+ int i = (int) o;
+ return i;
+ }
+
+ public static byte safeCast_ShortToByte(short o) {
+ if (o > Byte.MAX_VALUE) {
+ return Byte.MAX_VALUE;
+ }
+ else {
+ byte i = (byte) o;
+ return i;
+ }
+ }
+
+ public static short safeCast_ByteToshort(byte o) {
+ short i = (short) o;
+ return i;
+ }
+
}
diff --git a/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java
index 165a7931cb..c7c38eab7d 100644
--- a/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java
+++ b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java
@@ -724,7 +724,20 @@ public class ItemUtils {
}
return (gregstack);
}
+
+ public static ItemStack getOrePrefixStack(OrePrefixes mPrefix, Materials mMat, int mAmount) {
+ ItemStack aGtStack = GT_OreDictUnificator.get(mPrefix, mMat, mAmount);
+ if (aGtStack == null) {
+ return getErrorStack(mAmount);
+ }
+ else {
+ return aGtStack;
+ }
+ }
+ public static ItemStack getErrorStack(int mAmount) {
+ return getSimpleStack(ModItems.AAA_Broken, mAmount);
+ }
public static ItemStack[] getStackOfAllOreDictGroup(String oredictname){
final ArrayList<ItemStack> oreDictList = OreDictionary.getOres(oredictname);
if (!oreDictList.isEmpty()){
diff --git a/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java
index 0eb888209a..32607e1247 100644
--- a/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java
+++ b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java
@@ -1,25 +1,39 @@
package gtPlusPlus.core.util.minecraft;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
import java.util.List;
+import java.util.ListIterator;
import java.util.Map;
import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentSkipListSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.lang3.reflect.FieldUtils;
+import com.google.common.collect.Lists;
+
import net.minecraft.item.ItemStack;
import gregtech.api.enums.*;
-
+import gregtech.api.util.GT_Utility;
import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
import gtPlusPlus.api.objects.data.TypeCounter;
+import gtPlusPlus.core.client.CustomTextureSet.TextureSets;
import gtPlusPlus.core.lib.CORE;
import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialStack;
import gtPlusPlus.core.material.state.MaterialState;
import gtPlusPlus.core.util.Utils;
import gtPlusPlus.core.util.data.EnumUtils;
import gtPlusPlus.core.util.data.StringUtils;
+import gtPlusPlus.core.util.math.MathUtils;
import gtPlusPlus.core.util.reflect.ReflectionUtils;
import net.minecraftforge.oredict.OreDictionary;
@@ -45,88 +59,139 @@ public class MaterialUtils {
return null;
}
+ private static Map<String, Material> mGeneratedMaterialMap = new HashMap();
public static Material generateMaterialFromGtENUM(final Materials material){
- return generateMaterialFromGtENUM(material, null);
+ return generateMaterialFromGtENUM(material, null, null);
+ }
+
+ public static Material generateMaterialFromGtENUM(final Materials material, TextureSet aCustomTextures){
+ return generateMaterialFromGtENUM(material, null, aCustomTextures);
}
public static Material generateMaterialFromGtENUM(final Materials material, short[] customRGB){
- @SuppressWarnings("deprecation")
- String name = material.name();
- final short[] rgba = (customRGB == null ? material.mRGBa : customRGB);
- final int melting = material.mMeltingPoint;
- final int boiling = material.mBlastFurnaceTemp;
- final long protons = material.getProtons();
- final long neutrons = material.getNeutrons();
- final boolean blastFurnace = material.mBlastFurnaceRequired;
- final TextureSet iconSet = material.mIconSet;
- final int durability = material.mDurability;
- boolean mGenerateCell = false;
- boolean mGenerateFluid = true;
- MaterialState materialState;
- String chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mChemicalFormula));
- final Element element = material.mElement;
- int radioactivity = 0;
- if (material.isRadioactive()){
- radioactivity = 1;
- }
-
- //Weird Blacklist of Bad Chemical Strings
- if (material.mElement == Element.Pb || material.mElement == Element.Na || material.mElement == Element.Ar){
- chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mElement.name()));
- }
-
- //Determine default state
- Logger.MATERIALS("[Debug] Setting State of GT generated material. "+material.mDefaultLocalName);
- if (material.getMolten(1) != null || material.getSolid(1) != null){
- materialState = MaterialState.SOLID;
- Logger.MATERIALS("[Debug] Molten or Solid was not null.");
- if (material.getMolten(1) == null && material.getSolid(1) != null){
- Logger.MATERIALS("[Debug] Molten is Null, Solid is not. Enabling cell generation.");
- mGenerateCell = true;
+ return generateMaterialFromGtENUM(material, customRGB, null);
+ }
+
+ public static Material generateMaterialFromGtENUM(final Materials material, short[] customRGB, TextureSet aCustomTextures){
+ String aMaterialKey = getMaterialName(material).toLowerCase();
+ if (mGeneratedMaterialMap.containsKey(aMaterialKey)) {
+ return mGeneratedMaterialMap.get(aMaterialKey);
+ }
+
+ try {
+ @SuppressWarnings("deprecation")
+ String name = material.name();
+ final short[] rgba = (customRGB == null ? material.mRGBa : customRGB);
+ final int melting = material.mMeltingPoint;
+ final int boiling = material.mBlastFurnaceTemp;
+ final long protons = material.getProtons();
+ final long neutrons = material.getNeutrons();
+ final boolean blastFurnace = material.mBlastFurnaceRequired;
+ Integer radioactivity = 0;
+ if (material.isRadioactive()){
+ ItemStack aDustStack = ItemUtils.getOrePrefixStack(OrePrefixes.dust, material, 1);
+ radioactivity = aDustStack != null ? GT_Utility.getRadioactivityLevel(aDustStack) : 0;
+ if (radioactivity == 0) {
+ long aProtons = material.getProtons();
+ radioactivity = (int) Math.min(Math.max((aProtons / 30), 1), 9);
+ }
}
- else if (material.getMolten(1) != null && material.getSolid(1) == null){
- Logger.MATERIALS("[Debug] Molten is not Null, Solid is null. Not enabling cell generation.");
- //mGenerateCell = true;
+ Logger.MATERIALS("[Debug] Calculated Radiation level to be "+radioactivity.intValue()+".");
+ TextureSet iconSet = null;
+ if (aCustomTextures == null) {
+ if (material.isRadioactive()) {
+ iconSet = TextureSets.NUCLEAR.get();
+ }
+ else {
+ iconSet = material.mIconSet;
+ }
}
- Logger.MATERIALS("[Debug] State set as solid.");
- }
- else if (material.getFluid(1) != null){
- Logger.MATERIALS("[Debug] State set as liquid.");
- materialState = MaterialState.LIQUID;
- }
- else if (material.getGas(1) != null){
- Logger.MATERIALS("[Debug] State set as gas.");
- materialState = MaterialState.GAS;
- }/*
+ else {
+ iconSet = aCustomTextures;
+ }
+ if (iconSet == null || iconSet.mSetName.toLowerCase().contains("fluid")) {
+ iconSet = TextureSet.SET_METALLIC;
+ }
+ Logger.MATERIALS("[Debug] Calculated Texture Set to be "+iconSet.mSetName+".");
+
+
+ final int durability = material.mDurability;
+ boolean mGenerateCell = false;
+ boolean mGenerateFluid = true;
+ MaterialState materialState;
+ String chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mChemicalFormula));
+ final Element element = material.mElement;
+
+
+ //Weird Blacklist of Bad Chemical Strings
+ if (material.mElement == Element.Pb || material.mElement == Element.Na || material.mElement == Element.Ar){
+ chemicalFormula = StringUtils.subscript(Utils.sanitizeString(material.mElement.name()));
+ }
+
+ //Determine default state
+ Logger.MATERIALS("[Debug] Setting State of GT generated material. "+material.mDefaultLocalName);
+ if (material.getMolten(1) != null || material.getSolid(1) != null){
+ materialState = MaterialState.SOLID;
+ Logger.MATERIALS("[Debug] Molten or Solid was not null.");
+ if (material.getMolten(1) == null && material.getSolid(1) != null){
+ Logger.MATERIALS("[Debug] Molten is Null, Solid is not. Enabling cell generation.");
+ mGenerateCell = true;
+ }
+ else if (material.getMolten(1) != null && material.getSolid(1) == null){
+ Logger.MATERIALS("[Debug] Molten is not Null, Solid is null. Not enabling cell generation.");
+ //mGenerateCell = true;
+ }
+ Logger.MATERIALS("[Debug] State set as solid.");
+ }
+ else if (material.getFluid(1) != null){
+ Logger.MATERIALS("[Debug] State set as liquid.");
+ materialState = MaterialState.LIQUID;
+ }
+ else if (material.getGas(1) != null){
+ Logger.MATERIALS("[Debug] State set as gas.");
+ materialState = MaterialState.GAS;
+ }/*
else if (material.getPlasma(1) != null){
Logger.MATERIALS("[Debug] State set as plasma.");
materialState = MaterialState.PLASMA;
}*/
- else {
- Logger.MATERIALS("[Debug] State set as solid. This material has no alternative states, so for safety we wont generate anything.");
- materialState = MaterialState.SOLID;
- mGenerateFluid = false;
- }
+ else {
+ Logger.MATERIALS("[Debug] State set as solid. This material has no alternative states, so for safety we wont generate anything.");
+ materialState = MaterialState.SOLID;
+ mGenerateFluid = false;
+ }
- if (name.toLowerCase().contains("infused")){
- final String tempname = name.substring(7, name.length());
- name = "Infused " + tempname;
+ if (name.toLowerCase().contains("infused")){
+ final String tempname = name.substring(7, name.length());
+ name = "Infused " + tempname;
+ }
+ if (hasValidRGBA(rgba) || (element == Element.H) || ((material == Materials.InfusedAir) || (material == Materials.InfusedFire) || (material == Materials.InfusedEarth) || (material == Materials.InfusedWater))){
+ //ModItems.itemBaseDecidust = UtilsItems.generateDecidust(material);
+ //ModItems.itemBaseCentidust = UtilsItems.generateCentidust(material);
+ Material M = new Material(name, materialState,iconSet, durability, rgba, melting, boiling, protons, neutrons, blastFurnace, chemicalFormula, radioactivity.intValue(), mGenerateCell, mGenerateFluid);
+ mGeneratedMaterialMap.put(aMaterialKey, M);
+ return M;
+ }
+ else {
+ Logger.DEBUG_MATERIALS("Failed to generate GT++ material instance for "+material.name() +" | Valid RGB? "+(hasValidRGBA(rgba)));
+ }
}
- if (hasValidRGBA(rgba) || (element == Element.H) || ((material == Materials.InfusedAir) || (material == Materials.InfusedFire) || (material == Materials.InfusedEarth) || (material == Materials.InfusedWater))){
- //ModItems.itemBaseDecidust = UtilsItems.generateDecidust(material);
- //ModItems.itemBaseCentidust = UtilsItems.generateCentidust(material);
- return new Material(name, materialState,iconSet, durability, rgba, melting, boiling, protons, neutrons, blastFurnace, chemicalFormula, radioactivity, mGenerateCell, mGenerateFluid);
- }
- else {
- Logger.DEBUG_MATERIALS("Failed to generate GT++ material instance for "+material.name() +" | Valid RGB? "+(hasValidRGBA(rgba)));
+ catch (Throwable t) {
+ Logger.DEBUG_MATERIALS("Failed to generate GT++ material instance for "+material.name());
+ t.printStackTrace();
}
return null;
}
public static Material generateQuickMaterial(final String materialName, final MaterialState defaultState, final short[] colour, final int sRadioactivity) {
+ String aMaterialKey = materialName.toLowerCase();
+ if (mGeneratedMaterialMap.containsKey(aMaterialKey)) {
+ return mGeneratedMaterialMap.get(aMaterialKey);
+ }
+
final Material temp = new Material(
materialName,
defaultState,
@@ -138,6 +203,7 @@ public class MaterialUtils {
false,
"",
sRadioactivity);
+ mGeneratedMaterialMap.put(aMaterialKey, temp);
return temp;
}
@@ -237,7 +303,7 @@ public class MaterialUtils {
@SuppressWarnings("deprecation")
public static String getMaterialName(Materials mat){
-
+
String mName = null;
try {
@@ -281,5 +347,81 @@ public class MaterialUtils {
return m;
}
+ public static AutoMap<Material> getCompoundMaterialsRecursively(Material aMat){
+ return getCompoundMaterialsRecursively_Speiger(aMat);
+ /*
+ AutoMap<Material> aDataSet = new AutoMap<Material>();
+ final int HARD_LIMIT = 1000;
+ int mLoopCounter = 0;
+ if (aMat.getComposites().size() > 0) {
+ try {
+ List<Material> xList = Lists.newLinkedList();
+ for (MaterialStack kj : aMat.getComposites()) {
+ xList.add(kj.getStackMaterial());
+ }
+ if (xList.isEmpty()) {
+ aDataSet.put(aMat);
+ return aDataSet;
+ }
+ ListIterator<Material> listIterator = xList.listIterator();
+ while(listIterator.hasNext()){
+ Material e = listIterator.next();
+ listIterator.remove();
+ if (mLoopCounter > HARD_LIMIT) {
+ break;
+ }
+
+ if (e.getComposites().isEmpty()) {
+ aDataSet.put(e);
+ }
+ else {
+ for (MaterialStack x : e.getComposites()) {
+ listIterator.add(x.getStackMaterial());
+ }
+ }
+ mLoopCounter++;
+
+
+ }}
+ catch (Throwable t) {
+ aDataSet.put(aMat);
+ t.printStackTrace();
+ }
+ }
+ if (aDataSet.isEmpty()) {
+ aDataSet.put(aMat);
+ return aDataSet;
+ }
+ return aDataSet;
+ */}
+
+ public static AutoMap<Material> getCompoundMaterialsRecursively_Speiger(Material toSearch) {
+ AutoMap<Material> resultList = new AutoMap<Material>();
+ if (toSearch.getComposites().isEmpty()) {
+ resultList.put(toSearch);
+ return resultList;
+ }
+ final int HARD_LIMIT = 1000;
+
+ // Could be a Deque but i dont use the interface
+ // enough to use it as default.
+ LinkedList<Material> toCheck = new LinkedList<Material>();
+
+ toCheck.add(toSearch);
+ int processed = 0;
+ while (toCheck.size() > 0 && processed < HARD_LIMIT) {
+ Material current = toCheck.remove();
+ if (current.getComposites().isEmpty()) {
+ resultList.put(current);
+ } else {
+ for (MaterialStack entry : current.getComposites()) {
+ toCheck.add(entry.getStackMaterial());
+ }
+ }
+ processed++;
+ }
+ return resultList;
+ }
+
} \ No newline at end of file
generated by cgit (git 2.46.0) at 2025-06-14 15:58:07 +0000