Merge addon sources

18 files changed, 2148 insertions, 0 deletions

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;
+    }
+
+    public final V getValue_2() {
+        return this.value;
+    }
+
+    public final C getValue_3() {
+        return this.count;
+    }
+}
diff --git a/src/main/java/gtPlusPlus/api/objects/data/TypeCounter.java b/src/main/java/gtPlusPlus/api/objects/data/TypeCounter.java
new file mode 100644
index 0000000000..ea12972af4
--- /dev/null
+++ b/src/main/java/gtPlusPlus/api/objects/data/TypeCounter.java
@@ -0,0 +1,177 @@
+package gtPlusPlus.api.objects.data;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import gtPlusPlus.api.objects.Logger;
+
+public class TypeCounter<V> implements Set<V> {
+
+    private Map<String, InternalTypeCounterObject<V>> mInternalMap = new LinkedHashMap<>();
+    private String mHighestValueKey;
+    private int mHighestValue = 0;
+    private final Class mClass;
+
+    public TypeCounter(Class o) {
+        Logger.WARNING("Created new TypeCounter for " + o.getName());
+        mClass = o;
+    }
+
+    public static class InternalTypeCounterObject<Z> {
+
+        private final Z mObject;
+        private int mCounter = 0;
+
+        public InternalTypeCounterObject(Z o) {
+            mObject = o;
+        }
+
+        public String hash() {
+            return String.valueOf(mObject.hashCode());
+        }
+
+        public Z get() {
+            return mObject;
+        }
+
+        public void add() {
+            mCounter++;
+        }
+
+        public int count() {
+            return mCounter;
+        }
+    }
+
+    @Override
+    public boolean add(V arg0) {
+        return add(arg0, null);
+    }
+
+    public boolean add(V arg0, String aKeyName) {
+        String aKey = aKeyName != null ? aKeyName : arg0.toString();
+        InternalTypeCounterObject<V> aValue = mInternalMap.get(aKey);
+        if (aValue == null) {
+            aValue = new InternalTypeCounterObject<>((V) arg0);
+            Logger.WARNING("Adding new key to map: " + aKey);
+        }
+        aValue.add();
+        int a = aValue.count();
+        if (a > mHighestValue) {
+            mHighestValue = a;
+            mHighestValueKey = aKey;
+            Logger.WARNING("New Highest Count - " + aKey + ":" + a);
+        }
+        mInternalMap.put(aKey, aValue);
+        Logger.WARNING(aKey + ":" + a);
+        return true;
+    }
+
+    @Override
+    public boolean addAll(Collection arg0) {
+        boolean aReturn = true;
+        for (Object o : arg0) {
+            if (mClass.isInstance(o)) {
+                V j = (V) o;
+                boolean b = add(j);
+                if (!b) {
+                    aReturn = false;
+                }
+            }
+        }
+        return aReturn;
+    }
+
+    @Override
+    public void clear() {
+        mInternalMap.clear();
+    }
+
+    @Override
+    public boolean contains(Object arg0) {
+        return mInternalMap.containsKey(arg0.toString());
+    }
+
+    @Override
+    public boolean containsAll(Collection arg0) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return mInternalMap.isEmpty();
+    }
+
+    @Override
+    public Iterator iterator() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean remove(Object arg0) {
+        InternalTypeCounterObject<V> aValue = mInternalMap.remove(arg0.toString());
+        if (aValue != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean removeAll(Collection arg0) {
+        boolean aReturn = true;
+        for (Object o : arg0) {
+            boolean a = remove(o);
+            if (!a) {
+                aReturn = false;
+            }
+        }
+        return aReturn;
+    }
+
+    @Override
+    public boolean retainAll(Collection arg0) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public int size() {
+        return this.mInternalMap.size();
+    }
+
+    @Override
+    public Object[] toArray() {
+        Object[] aArray = new Object[this.mInternalMap.size()];
+        int aPos = 0;
+        for (String k : this.mInternalMap.keySet()) {
+            if (k != null) {
+                InternalTypeCounterObject<V> aVal = this.mInternalMap.get(k);
+                aArray[aPos++] = new Pair<>(k, aVal);
+            }
+        }
+        return aArray;
+    }
+
+    @Override
+    public V[] toArray(Object[] a) {
+        Object[] aArray = new Object[a.length];
+        int aPos = 0;
+        for (Object k : a) {
+            if (k != null) {
+                aArray[aPos++] = k;
+            }
+        }
+        return (V[]) aArray;
+    }
+
+    public V getResults() {
+        InternalTypeCounterObject<V> x = mInternalMap.get(mHighestValueKey);
+        return x.get();
+    }
+}
diff --git a/src/main/java/gtPlusPlus/api/objects/data/WeightedCollection.java b/src/main/java/gtPlusPlus/api/objects/data/WeightedCollection.java
new file mode 100644
index 0000000000..5d99097169
--- /dev/null
+++ b/src/main/java/gtPlusPlus/api/objects/data/WeightedCollection.java
@@ -0,0 +1,102 @@
+package gtPlusPlus.api.objects.data;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeMap;
+
+import gregtech.api.objects.XSTR;
+
+public class WeightedCollection<E> implements Map<Integer, E> {
+
+    private NavigableMap<Integer, E> map = new TreeMap<>();
+    private Random random;
+    private int total = 0;
+
+    public WeightedCollection() {
+        this(new XSTR());
+    }
+
+    public WeightedCollection(Random random) {
+        this.random = random;
+    }
+
+    public E add(int weight, E object) {
+        if (weight <= 0) return null;
+        total += weight;
+        return map.put(total, object);
+    }
+
+    private E next() {
+        int value = random.nextInt(total) + 1; // Can also use floating-point weights
+        return map.ceilingEntry(value)
+            .getValue();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return map.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return map.containsValue(value);
+    }
+
+    public E get() {
+        return next();
+    }
+
+    @Override
+    public E get(Object key) {
+        return next();
+    }
+
+    @Override
+    public void putAll(Map m) {
+        map.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+        this.total = 0;
+    }
+
+    @Override
+    public Set keySet() {
+        return map.keySet();
+    }
+
+    @Override
+    public Collection values() {
+        return map.values();
+    }
+
+    @Override
+    public Set entrySet() {
+        return map.entrySet();
+    }
+
+    @Override
+    public E put(Integer key, E value) {
+        return add(key, value);
+    }
+
+    @Override
+    public E remove(Object key) {
+        return map.remove(key);
+    }
+}
diff --git a/src/main/java/gtPlusPlus/api/objects/data/weakref/WeakAutoMap.java b/src/main/java/gtPlusPlus/api/objects/data/weakref/WeakAutoMap.java
new file mode 100644
index 0000000000..199d20e06a
--- /dev/null
+++ b/src/main/java/gtPlusPlus/api/objects/data/weakref/WeakAutoMap.java
@@ -0,0 +1,14 @@
+package gtPlusPlus.api.objects.data.weakref;
+
+import java.util.WeakHashMap;
+
+import gtPlusPlus.api.objects.data.AutoMap;
+
+public class WeakAutoMap<T> extends AutoMap<T> {
+
+    private static final long serialVersionUID = 8328345351801363386L;
+
+    public WeakAutoMap() {
+        super(new WeakHashMap<>());
+    }
+}
diff --git a/src/main/java/gtPlusPlus/api/objects/minecraft/AABB.java b/src/main/java/gtPlusPlus/api/objects/minecraft/AABB.java
new file mode 100644
index 0000000000..e516f12ddd
--- /dev/null
+++ b/src/main/java/gtPlusPlus/api/objects/minecraft/AABB.java
@@ -0,0 +1,67 @@
+package gtPlusPlus.api.objects.minecraft;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+
+import gtPlusPlus.core.util.minecraft.EntityUtils;
+
+/**
+ * Generates an AABB around an entity.
+ * 
+ * @author Alkalus
+ *
+ */
+public class AABB {
+
+    private final AxisAlignedBB mAabb;
+    private final World mWorld;
+
+    /**
+     * Creates a AxisAlignedBB based around an Entity.
+     * 
+     * @param aEntity - The Entity to work with.
+     * @param x       - Maximum X from origin.
+     * @param y       - Maximum Y from origin.
+     * @param z       - Maximum Z from origin.
+     */
+    publi