diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/api')
29 files changed, 2923 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java b/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java new file mode 100644 index 0000000000..d2a1e34f99 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java @@ -0,0 +1,139 @@ +package gtPlusPlus.api.interfaces; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public interface ILazyCoverable extends ICoverable { + + @Override + default byte getColorization() { + return 0; + } + + @Override + default byte setColorization(byte arg0) { + return 0; + } + + @Override + default byte getInputRedstoneSignal(ForgeDirection side) { + return 0; + } + + @Override + default byte getStrongestRedstone() { + return 0; + } + + @Override + default boolean getRedstone() { + // TODO Auto-generated method stub + return false; + } + + @Override + default boolean getRedstone(ForgeDirection side) { + return false; + } + + @Override + default boolean isUniversalEnergyStored(long arg0) { + return false; + } + + @Override + default long getUniversalEnergyStored() { + return 0; + } + + @Override + default long getUniversalEnergyCapacity() { + return 0; + } + + @Override + default long getStoredSteam() { + return 0; + } + + @Override + default long getSteamCapacity() { + return 0; + } + + @Override + default boolean increaseStoredSteam(long arg0, boolean arg2) { + return false; + } + + @Override + default byte getOutputRedstoneSignal(ForgeDirection side) { + return 0; + } + + @Override + default void setOutputRedstoneSignal(ForgeDirection side, byte strength) {} + + @Override + default byte getStrongOutputRedstoneSignal(ForgeDirection side) { + return 0; + } + + @Override + default void setStrongOutputRedstoneSignal(ForgeDirection side, byte arg1) {} + + @Override + default byte getComparatorValue(ForgeDirection side) { + return 0; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntity(int arg0, int arg1, int arg2) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityOffset(int arg0, int arg1, int arg2) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityAtSide(ForgeDirection side) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int arg1) { + return null; + } + + @Override + default byte getMetaID(int arg0, int arg1, int arg2) { + return 0; + } + + @Override + default byte getMetaIDOffset(int arg0, int arg1, int arg2) { + return 0; + } + + @Override + default byte getMetaIDAtSide(ForgeDirection side) { + return 0; + } + + @Override + default byte getMetaIDAtSideAndDistance(ForgeDirection side, int arg1) { + return 0; + } + + @Override + default boolean isDead() { + return false; + } + + @Override + default void setLightValue(byte arg0) {} +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java b/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java new file mode 100644 index 0000000000..d70a19925e --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java @@ -0,0 +1,41 @@ +package gtPlusPlus.api.interfaces; + +import gtPlusPlus.api.objects.Logger; + +public interface IPlugin { + + /** + * @return A {@link String} object which returns the {@link IPlugin}'s name. + */ + public String getPluginName(); + + /** + * @return A {@link String} object which returns the {@link IPlugin}'s short name. This String should only contain 4 + * Characters. + */ + public String getPluginAbbreviation(); + + /** + * @param message - A {@link String} object which holds a message to be logged to console. + */ + default void log(String message) { + Logger.INFO("[" + getPluginAbbreviation() + "] " + message); + } + + /** + * @param message - A {@link String} object which holds a warning/error message to be logged to console. + */ + default void logDebug(String message) { + Logger.WARNING("[" + getPluginAbbreviation() + "] " + message); + } + + public boolean preInit(); + + public boolean init(); + + public boolean postInit(); + + public boolean serverStart(); + + public boolean serverStop(); +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java b/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java new file mode 100644 index 0000000000..a6179ce2bf --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java @@ -0,0 +1,15 @@ +package gtPlusPlus.api.interfaces; + +import net.minecraft.block.Block; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ITexturedTileEntity; + +public interface ITexturedBlock extends ITexturedTileEntity { + + ITexture[] getTexture(ForgeDirection side); + + @Override + ITexture[] getTexture(Block block, ForgeDirection side); +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java b/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java new file mode 100644 index 0000000000..f059ef8a5f --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java @@ -0,0 +1,6 @@ +package gtPlusPlus.api.interfaces; + +public interface ITileTooltip { + + int getTooltipID(); +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java b/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java new file mode 100644 index 0000000000..f00287404b --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java @@ -0,0 +1,7 @@ +package gtPlusPlus.api.interfaces; + +public interface RunnableWithInfo<V> extends Runnable { + + V getInfoData(); + +} diff --git a/src/main/java/gtPlusPlus/api/objects/Logger.java b/src/main/java/gtPlusPlus/api/objects/Logger.java new file mode 100644 index 0000000000..0178bb141a --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/Logger.java @@ -0,0 +1,162 @@ +package gtPlusPlus.api.objects; + +import org.apache.logging.log4j.LogManager; + +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.relauncher.FMLRelaunchLog; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.preloader.CORE_Preloader; +import gtPlusPlus.preloader.asm.AsmConfig; + +public class Logger { + + public Logger() {} + + // Logging Functions + public static final org.apache.logging.log4j.Logger modLogger = Logger.makeLogger(); + + // Generate GT++ Logger + public static org.apache.logging.log4j.Logger makeLogger() { + final org.apache.logging.log4j.Logger gtPlusPlusLogger = LogManager.getLogger("GT++"); + return gtPlusPlusLogger; + } + + private static final boolean enabled = !AsmConfig.disableAllLogging; + + public static final org.apache.logging.log4j.Logger getLogger() { + return modLogger; + } + + // Non-Dev Comments + public static void INFO(final String s) { + if (enabled) { + modLogger.info(s); + } + } + + // Non-Dev Comments + public static void MACHINE_INFO(String s, Object... args) { + if (enabled) { + boolean localPlayer = CORE_Preloader.DEV_ENVIRONMENT; + if (CORE.ConfigSwitches.MACHINE_INFO || localPlayer) { + final String name1 = gtPlusPlus.core.util.reflect.ReflectionUtils.getMethodName(2); + modLogger.info("Machine Info: " + s + " | " + name1, args); + } + } + } + + // Developer Comments + public static void WARNING(final String s) { + if (enabled) { + if (CORE_Preloader.DEBUG_MODE) { + modLogger.warn(s); + } + } + } + + // Errors + public static void ERROR(final String s) { + if (enabled) { + if (CORE_Preloader.DEBUG_MODE) { + modLogger.fatal(s); + } + } + } + + // Developer Logger + public static void SPECIFIC_WARNING(final String whatToLog, final String msg, final int line) { + if (enabled) { + // if (!CORE_Preloader.DEBUG_MODE){ + FMLLog.warning("GT++ |" + line + "| " + whatToLog + " | " + msg); + // } + } + } + + // ASM Comments + public static void LOG_ASM(final String s) { + if (enabled) { + FMLRelaunchLog.info("[Special ASM Logging] ", s); + } + } + + /** + * Special Loggers + */ + + /** + * Special Logger for Bee related content + */ + public static void BEES(final String s) { + modLogger.info("[Bees] " + s); + } + + /** + * Special Logger for Debugging Bee related content + */ + public static void DEBUG_BEES(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Debug][Bees] " + s); + } + } + } + + /** + * Special Logger for Materials related content + */ + public static void MATERIALS(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Materials] " + s); + } + } + } + + /** + * Special Logger for Debugging Materials related content + */ + public static void DEBUG_MATERIALS(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Debug][Materials] " + s); + } + } + } + + /** + * Special Logger for Reflection related content + */ + public static void REFLECTION(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Reflection] " + s); + } + } + } + + /** + * Special Logger for Darkworld related content + */ + public static void WORLD(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[WorldGen] " + s); + } + } + } + + public static void RECIPE(String string) { + if (enabled) { + if ( + /* CORE_Preloader.DEV_ENVIRONMENT || */ CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Recipe] " + string); + } + } + } + + public static void SPACE(final String s) { + if (enabled) { + modLogger.info("[Space] " + s); + } + } +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java b/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java new file mode 100644 index 0000000000..a3551326c2 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java @@ -0,0 +1,364 @@ +package gtPlusPlus.api.objects.data; + +import java.io.Serializable; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Queue; +import java.util.Set; + +public class AutoMap<V> implements Iterable<V>, Cloneable, Serializable, Collection<V>, Queue<V>, List<V> { + + /** + * The Internal Map + */ + protected final Map<Integer, V> mInternalMap; + + protected final Map<String, Integer> mInternalNameMap; + + /** + * The Internal ID + */ + private int mInternalID = 0; + + private static final long serialVersionUID = 3771412318075131790L; + + public AutoMap() { + this(new LinkedHashMap<>()); + } + + public Map<Integer, V> getMap() { + return mInternalMap; + } + + public AutoMap(Map<Integer, V> defaultMapType) { + mInternalMap = defaultMapType; + mInternalNameMap = new LinkedHashMap<>(); + } + + /** + * Generates an AutoMap from the List. + * + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(List<V> aList) { + mInternalMap = new LinkedHashMap<>(); + mInternalNameMap = new LinkedHashMap<>(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + + /** + * Generates an AutoMap from a Set. + * + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(Set<V> aList) { + mInternalMap = new LinkedHashMap<>(); + mInternalNameMap = new LinkedHashMap<>(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + + /** + * Generates an AutoMap from a Collection. + * + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(Collection<V> aList) { + mInternalMap = new LinkedHashMap<>(); + mInternalNameMap = new LinkedHashMap<>(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + + /** + * Generates an AutoMap from a Array. + * + * @param aArray - Data to be inserted into the AutoMap. + */ + public AutoMap(V[] aArray) { + mInternalMap = new LinkedHashMap<>(); + mInternalNameMap = new LinkedHashMap<>(); + if (aArray != null && aArray.length > 0) { + for (V obj : aArray) { + add(obj); + } + } + } + + @Override + public Iterator<V> iterator() { + return values().iterator(); + } + + public synchronized boolean setValue(V object) { + int mOriginalID = this.mInternalID; + put(object); + if (this.mInternalMap.get(mOriginalID) + .equals(object) || mOriginalID > this.mInternalID) { + return true; + } else { + return false; + } + } + + public synchronized V put(V object) { + return set(object); + } + + @Override + public synchronized boolean add(V object) { + return set(object) != null; + } + + public synchronized V set(V object) { + if (object == null) { + return null; + } + mInternalNameMap.put("" + object.hashCode(), (mInternalID + 1)); + return mInternalMap.put(mInternalID++, object); + } + + @Override + public synchronized V get(int id) { + return mInternalMap.get(id); + } + + public synchronized Collection<V> values() { + return mInternalMap.values(); + } + + @Override + public synchronized int size() { + return mInternalMap.size(); + } + + public synchronized int hashCode() { + return mInternalMap.hashCode(); + } + + public synchronized boolean containsKey(int key) { + return mInternalMap.containsKey(key); + } + + public synchronized boolean containsValue(V value) { + return mInternalMap.containsValue(value); + } + + @Override + public synchronized boolean isEmpty() { + return mInternalMap.isEmpty(); + } + + @Override + public synchronized void clear() { + this.mInternalID = 0; + this.mInternalMap.clear(); + this.mInternalNameMap.clear(); + return; + } + + @Override + @SuppressWarnings("unchecked") + public V[] toArray() { + V[] toR = (V[]) java.lang.reflect.Array.newInstance( + mInternalMap.get(0) + .getClass(), + mInternalMap.size()); + for (int i = 0; i < mInternalMap.size(); i++) { + toR[i] = mInternalMap.get(i); + } + return toR; + } + + public final synchronized int getInternalID() { + return mInternalID; + } + + @Override + public final synchronized boolean remove(Object value) { + value.getClass(); + if (this.mInternalMap.containsValue(value)) { + return this.mInternalMap.remove(mInternalNameMap.get("" + value.hashCode()), value); + } + return false; + } + + @Override + public boolean contains(Object o) { + for (V g : this.mInternalMap.values()) { + if (g.equals(o)) { + return true; + } + } + return false; + } + + @SuppressWarnings("unchecked") + @Override + public <V> V[] toArray(V[] a) { + return (V[]) toArray(); + } + + @Override + public boolean containsAll(Collection<?> c) { + boolean aTrue = true; + for (Object g : c) { + if (!this.contains(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean addAll(Collection<? extends V> c) { + boolean aTrue = true; + for (V g : c) { + if (!this.add(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean removeAll(Collection<?> c) { + boolean aTrue = true; + for (Object g : c) { + if (!this.remove(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean retainAll(Collection<?> c) { + AutoMap<?> aTempAllocation = new AutoMap<>(); + boolean aTrue = false; + aTempAllocation = this; + aTempAllocation.removeAll(c); + aTempAllocation.clear(); + aTrue = aTempAllocation.isEmpty(); + aTempAllocation.clear(); + return aTrue; + } + + @Override + public boolean offer(V e) { + return add(e); + } + + @Override + public V remove() { + V y = this.get(0); + if (remove(y)) return y; + else return null; + } + + @Override + public V poll() { + if (this.mInternalMap.isEmpty()) { + return null; + } + return remove(); + } + + @Override + public V element() { + if (this.mInternalMap.isEmpty()) { + return null; + } + return this.get(0); + } + + @Override + public V peek() { + return element(); + } + + @Override + public boolean addAll(int index, Collection<? extends V> c) { + for (V y : c) { + add(y); + } + return true; + } + + @Override + public V set(int index, V element) { + return mInternalMap.put(index, element); + } + + @Override + public void add(int index, V element) { + add(element); + } + + @Override + public V remove(int index) { + V h = mInternalMap.get(index); + set(index, null); + return h; + } + + @Override + public int indexOf(Object o) { + int aCount = 0; + for (V of : mInternalMap.values()) { + if (of != o) { + aCount++; + continue; + } else { + return aCount; + } + } + return -1; + } + + @Override + public int lastIndexOf(Object o) { + // TODO + return indexOf(o); + } + + @Override + public ListIterator<V> listIterator() { + // TODO Auto-generated method stub + return null; + } + + @Override + public ListIterator<V> listIterator(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List<V> subList(int fromIndex, int toIndex) { + AutoMap<V> aNewSubList = new AutoMap<>(); + for (int slot = fromIndex; slot <= toIndex; slot++) { + V obj = mInternalMap.get(slot); + if (obj == null) { + continue; + } else { + aNewSubList.put(obj); + } + } + return aNewSubList; + } +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/Pair.java b/src/main/java/gtPlusPlus/api/objects/data/Pair.java new file mode 100644 index 0000000000..93bf075c8f --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/Pair.java @@ -0,0 +1,35 @@ +package gtPlusPlus.api.objects.data; + +import java.io.Serializable; + +import com.google.common.base.Objects; + +public class Pair<K, V> implements Serializable { + + /** + * SVUID + */ + private static final long serialVersionUID = 1250550491092812443L; + + private final K key; + private final V value; + + public Pair(final K key, final V value) { + this.key = key; + this.value = value; + } + + public final K getKey() { + return this.key; + } + + public final V getValue() { + return this.value; + } + + @Override + public int hashCode() { + Integer aCode = Objects.hashCode(getKey(), getValue()); + return aCode != null ? aCode : super.hashCode(); + } +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/Quad.java b/src/main/java/gtPlusPlus/api/objects/data/Quad.java new file mode 100644 index 0000000000..a2597061e0 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/Quad.java @@ -0,0 +1,44 @@ +package gtPlusPlus.api.objects.data; + +import java.util.ArrayList; +import java.util.List; + +public class Quad<K, V, C, R> { + + private final K key; + private final V value; + private final C value2; + private final R value3; + + public Quad(final K key, final V value, final C value2, final R value3) { + this.key = key; + this.value = value; + this.value2 = value2; + this.value3 = value3; + } + + public final K getKey() { + return this.key; + } + + public final V getValue_1() { + return this.value; + } + + public final C getValue_2() { + return this.value2; + } + + public final R getValue_3() { + return this.value3; + } + + public final List values() { + List<Object> aVals = new ArrayList<>(); + aVals.add(key); + aVals.add(value); + aVals.add(value2); + aVals.add(value3); + return aVals; + } +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/Triplet.java b/src/main/java/gtPlusPlus/api/objects/data/Triplet.java new file mode 100644 index 0000000000..625ec630aa --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/Triplet.java @@ -0,0 +1,26 @@ +package gtPlusPlus.api.objects.data; + +public class Triplet<K, V, C> { + + private final K key; + private final V value; + private final C count; + + public Triplet(final K key, final V value, final C value2) { + this.key = key; + this.value = value; + this.count = value2; + } + + public final K getValue_1() { + return this.key; + } + |