13 files changed, 1611 insertions, 168 deletions
diff --git a/src/main/java/gregtech/common/GT_Proxy.java b/src/main/java/gregtech/common/GT_Proxy.java
index 5b3c4e8b79..100b5016ab 100644
--- a/src/main/java/gregtech/common/GT_Proxy.java
+++ b/src/main/java/gregtech/common/GT_Proxy.java
@@ -8,6 +8,9 @@ import cpw.mods.fml.common.network.FMLNetworkEvent;
 import cpw.mods.fml.common.network.IGuiHandler;
 import cpw.mods.fml.common.network.NetworkRegistry;
 import cpw.mods.fml.common.registry.GameRegistry;
+import forestry.api.genetics.AlleleManager;
+import forestry.apiculture.genetics.Bee;
+import forestry.core.genetics.alleles.AlleleHelper;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.*;
 import gregtech.api.enums.TC_Aspects.TC_AspectStack;
@@ -44,6 +47,7 @@ import net.minecraft.item.ItemBow;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.CraftingManager;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
 import net.minecraft.potion.Potion;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.DamageSource;
@@ -72,6 +76,7 @@ import net.minecraftforge.oredict.OreDictionary;
 import net.minecraftforge.oredict.RecipeSorter;
 import net.minecraftforge.oredict.ShapedOreRecipe;
 import net.minecraftforge.oredict.ShapelessOreRecipe;
+import org.apache.commons.lang3.text.WordUtils;
 
 import static gregtech.GT_Mod.GT_FML_LOGGER;
 
@@ -1312,6 +1317,104 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler {
                             tCount += tStack.stackSize * 64 / Math.max(1, tStack.getMaxStackSize());
                         }
                         if (this.mInventoryUnification) {
+
+                            if (tStack.getTagCompound()!= null && (tStack.getTagCompound().getTag("Mate")!= null || tStack.getTagCompound().getTag("Genome")!= null )) {
+
+                                String orgMate = "";
+                                if(tStack.getTagCompound().getTag("Mate")!= null)
+                                    orgMate = (tStack.getTagCompound().getCompoundTag("Mate")).getTagList("Chromosomes",10).getCompoundTagAt(0).getString("UID1");
+
+                                String orgGen = orgMate;
+
+                                if(tStack.getTagCompound().getTag("Genome")!= null)
+                                    orgGen = (tStack.getTagCompound().getCompoundTag("Genome")).getTagList("Chromosomes",10).getCompoundTagAt(0).getString("UID1");
+
+                                final boolean[] yn = {orgMate.contains("gendustry"),orgGen.contains("gendustry")};
+
+                                if (yn[0] || yn[1]) {
+
+                                    final NBTTagCompound NBTTAGCOMPOUND = (NBTTagCompound) tStack.getTagCompound().copy();
+
+                                    //MATE
+                                    if (yn[0]) {
+                                        final NBTTagCompound MATE = NBTTAGCOMPOUND.getCompoundTag("Mate");
+                                        final NBTTagList chromosomesMate = MATE.getTagList("Chromosomes", 10);
+                                        final NBTTagCompound species = chromosomesMate.getCompoundTagAt(0);
+
+                                        String ident1 = species.getString("UID1");
+                                        final String[] split = ident1.split("[.]");
+                                        ident1 = "gregtech.bee.species" + WordUtils.capitalize(split[2].toLowerCase(Locale.ENGLISH));
+
+                                        if (AlleleManager.alleleRegistry.getAllele(ident1) == null)
+                                            return;
+
+                                        String ident2 = species.getString("UID0");
+                                        final String[] split2 = ident2.split("[.]");
+                                        ident2 = "gregtech.bee.species"+WordUtils.capitalize(split2[2].toLowerCase(Locale.ENGLISH));
+
+                                        if (AlleleManager.alleleRegistry.getAllele(ident2) == null)
+                                            return;
+
+                                        final NBTTagCompound nuspeciesmate = new NBTTagCompound();
+                                        nuspeciesmate.setString("UID1", ident1);
+                                        nuspeciesmate.setString("UID0", ident2);
+                                        nuspeciesmate.setByte("Slot", (byte) 0);
+
+                                        final NBTTagCompound nuMate2 = new NBTTagCompound();
+                                        final NBTTagList nuMate = new NBTTagList();
+                                        nuMate.appendTag(nuspeciesmate);
+
+                                        for (int j = 1; j < chromosomesMate.tagCount(); j++) {
+                                            nuMate.appendTag(chromosomesMate.getCompoundTagAt(j));
+                                        }
+
+                                        nuMate2.setTag("Chromosomes", nuMate);
+                                        NBTTAGCOMPOUND.removeTag("Mate");
+                                        NBTTAGCOMPOUND.setTag("Mate", nuMate2);
+                                    }
+                                    if (yn[1]) {
+                                        //Genome
+                                        final NBTTagCompound genome = NBTTAGCOMPOUND.getCompoundTag("Genome");
+                                        final NBTTagList chromosomesGenome = genome.getTagList("Chromosomes", 10);
+                                        final NBTTagCompound speciesGenome = chromosomesGenome.getCompoundTagAt(0);
+
+                                        String ident1Genome = speciesGenome.getString("UID1");
+                                        final String[] splitGenome = ident1Genome.split("[.]");
+                                        ident1Genome = "gregtech.bee.species" + WordUtils.capitalize(splitGenome[2].toLowerCase(Locale.ENGLISH));
+
+                                        if (AlleleManager.alleleRegistry.getAllele(ident1Genome) == null)
+                                            return;
+
+                                        String ident2Genome = speciesGenome.getString("UID0");
+                                        final String[] splitGenome2 = ident2Genome.split("[.]");
+                                        ident2Genome = "gregtech.bee.species" + WordUtils.capitalize(splitGenome2[2].toLowerCase(Locale.ENGLISH));
+
+                                        if (AlleleManager.alleleRegistry.getAllele(ident2Genome) == null)
+                                            return;
+
+                                        final NBTTagCompound nuspeciesgenome = new NBTTagCompound();
+                                        nuspeciesgenome.setString("UID1", ident1Genome);
+                                        nuspeciesgenome.setString("UID0", ident2Genome);
+                                        nuspeciesgenome.setByte("Slot", (byte) 0);
+
+                                        final NBTTagCompound nugenome2 = new NBTTagCompound();
+                                        final NBTTagList nuGenome = new NBTTagList();
+                                        nuGenome.appendTag(nuspeciesgenome);
+
+                                        for (int j = 1; j < chromosomesGenome.tagCount(); j++) {
+                                            nuGenome.appendTag(chromosomesGenome.getCompoundTagAt(j));
+                                        }
+
+                                        nugenome2.setTag("Chromosomes", nuGenome);
+                                        NBTTAGCOMPOUND.removeTag("Genome");
+                                        NBTTAGCOMPOUND.setTag("Genome", nugenome2);
+                                    }
+                                    tStack.setTagCompound(new NBTTagCompound());
+                                    tStack.setTagCompound(NBTTAGCOMPOUND);
+                                }
+                                else return;
+                            }
+
                             GT_OreDictUnificator.setStack(true, tStack);
                         }
                     }
diff --git a/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java b/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java
new file mode 100644
index 0000000000..83dc82e6f9
--- /dev/null
+++ b/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java
@@ -0,0 +1,39 @@
+package gregtech.common.bees;
+
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.apiculture.IAlleleBeeSpeciesCustom;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IClassification;
+import forestry.apiculture.genetics.alleles.AlleleBeeSpecies;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+
+public class GT_AlleleBeeSpecies extends AlleleBeeSpecies {
+    public GT_AlleleBeeSpecies(String uid, boolean dominant, String unlocalizedName, String authority, String unlocalizedDescription, IClassification branch, String binomial, int primaryColor, int secondaryColor) {
+        super(uid, unlocalizedName, authority, unlocalizedDescription, dominant, branch, binomial, primaryColor, secondaryColor);
+        AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.SPECIES);
+    }
+
+    @Override
+    public IAlleleBeeSpeciesCustom addProduct(ItemStack product, Float chance) {
+        if (product == null || product.getItem() == null) {
+            product=new ItemStack(Items.boat);
+        }
+        if (chance <= 0.0f || chance > 1.0f) {
+            chance = 0.1f;
+        }
+        return super.addProduct(product,chance);
+    }
+
+    @Override
+    public IAlleleBeeSpeciesCustom addSpecialty(ItemStack specialty, Float chance) {
+        if (specialty == null || specialty.getItem() == null) {
+            specialty=new ItemStack(Items.boat);
+        }
+        if (chance <= 0.0f || chance > 1.0f) {
+            chance = 0.1f;
+        }
+        return super.addSpecialty(specialty, chance);
+    }
+
+}
diff --git a/src/main/java/gregtech/common/bees/GT_AlleleHelper.java b/src/main/java/gregtech/common/bees/GT_AlleleHelper.java
new file mode 100644
index 0000000000..3431f96eb4
--- /dev/null
+++ b/src/main/java/gregtech/common/bees/GT_AlleleHelper.java
@@ -0,0 +1,224 @@
+package gregtech.common.bees;
+
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.arboriculture.EnumTreeChromosome;
+import forestry.api.genetics.*;
+import forestry.api.lepidopterology.EnumButterflyChromosome;
+import forestry.apiculture.flowers.FlowerProvider;
+import forestry.core.config.Constants;
+import forestry.core.genetics.alleles.*;
+import forestry.core.utils.vect.IVect;
+import forestry.plugins.PluginManager;
+
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+public class GT_AlleleHelper extends AlleleHelper {
+
+    private static final String modId = Constants.ID;
+
+    private final Map<Class, Map<?, ? extends IAllele>> alleleMaps = new HashMap<>();
+
+    public void init() {
+        if (PluginManager.Module.APICULTURE.isEnabled()) {
+            createAlleles(EnumAllele.Fertility.class, EnumBeeChromosome.FERTILITY);
+            createAlleles(EnumAllele.Flowering.class, EnumBeeChromosome.FLOWERING);
+        }
+
+        if (PluginManager.Module.APICULTURE.isEnabled() || PluginManager.Module.ARBORICULTURE.isEnabled()) {
+            createAlleles(EnumAllele.Territory.class,
+                    EnumBeeChromosome.TERRITORY,
+                    EnumTreeChromosome.TERRITORY
+            );
+
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.territoryDefault", get(EnumAllele.Territory.AVERAGE));
+        }
+
+        if (PluginManager.Module.APICULTURE.isEnabled() || PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) {
+            createAlleles(EnumAllele.Speed.class,
+                    EnumBeeChromosome.SPEED,
+                    EnumButterflyChromosome.SPEED
+            );
+            createAlleles(EnumAllele.Lifespan.class,
+                    EnumBeeChromosome.LIFESPAN,
+                    EnumButterflyChromosome.LIFESPAN
+            );
+            createAlleles(EnumAllele.Tolerance.class,
+                    EnumBeeChromosome.TEMPERATURE_TOLERANCE,
+                    EnumBeeChromosome.HUMIDITY_TOLERANCE,
+                    EnumButterflyChromosome.TEMPERATURE_TOLERANCE,
+                    EnumButterflyChromosome.HUMIDITY_TOLERANCE
+            );
+            createAlleles(EnumAllele.Flowers.class,
+                    EnumBeeChromosome.FLOWER_PROVIDER,
+                    EnumButterflyChromosome.FLOWER_PROVIDER
+            );
+
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.speedNorm", get(EnumAllele.Speed.NORMAL));
+        }
+
+        if (PluginManager.Module.ARBORICULTURE.isEnabled()) {
+            createAlleles(EnumAllele.Height.class, EnumTreeChromosome.HEIGHT);
+            createAlleles(EnumAllele.Saplings.class, EnumTreeChromosome.FERTILITY);
+            createAlleles(EnumAllele.Yield.class, EnumTreeChromosome.YIELD);
+            createAlleles(EnumAllele.Fireproof.class, EnumTreeChromosome.FIREPROOF);
+            createAlleles(EnumAllele.Maturation.class, EnumTreeChromosome.MATURATION);
+            createAlleles(EnumAllele.Sappiness.class, EnumTreeChromosome.SAPPINESS);
+
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.heightMax10", get(EnumAllele.Height.AVERAGE));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsDefault", get(EnumAllele.Saplings.AVERAGE));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsDouble", get(EnumAllele.Saplings.HIGH));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsTriple", get(EnumAllele.Saplings.HIGHER));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.yieldDefault", get(EnumAllele.Yield.AVERAGE));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlowest", get(EnumAllele.Maturation.SLOWEST));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlower", get(EnumAllele.Maturation.SLOWER));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlow", get(EnumAllele.Maturation.SLOW));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityAverage", get(EnumAllele.Maturation.AVERAGE));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFast", get(EnumAllele.Maturation.FAST));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFaster", get(EnumAllele.Maturation.FASTER));
+            AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFastest", get(EnumAllele.Maturation.FASTEST));
+        }
+
+        if (PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) {
+            createAlleles(EnumAllele.Size.class, EnumButterflyChromosome.SIZE);
+        }
+
+        Map<Integer, IAlleleInteger> integers = new HashMap<>();
+        for (int i = 1; i <= 10; i++) {
+            IAlleleInteger alleleInteger = new AlleleInteger(modId, "i", i + "d", i, true);
+            AlleleManager.alleleRegistry.registerAllele(alleleInteger,
+                    EnumTreeChromosome.GIRTH,
+                    EnumButterflyChromosome.METABOLISM,
+                    EnumButterflyChromosome.FERTILITY
+            );
+            integers.put(i, alleleInteger);
+        }
+        alleleMaps.put(Integer.class, integers);
+
+        Map<Boolean, IAlleleBoolean> booleans = new HashMap<>();
+        booleans.put(true, new AlleleBoolean(modId, "bool", true, false));
+        booleans.put(false, new AlleleBoolean(modId, "bool", false, false));
+        for (IAlleleBoolean alleleBoolean : booleans.values()) {
+            AlleleManager.alleleRegistry.registerAllele(alleleBoolean,
+                    EnumBeeChromosome.NOCTURNAL,
+                    EnumBeeChromosome.TOLERANT_FLYER,
+                    EnumBeeChromosome.CAVE_DWELLING,
+                    EnumButterflyChromosome.NOCTURNAL,
+                    EnumButterflyChromosome.TOLERANT_FLYER,
+                    EnumButterflyChromosome.FIRE_RESIST
+            );
+        }
+        alleleMaps.put(Boolean.class, booleans);
+    }
+
+    public static void initialisation(){
+        AlleleHelper.instance = new GT_AlleleHelper();
+        AlleleHelper.instance.init();
+    }
+
+
+
+    @Override
+    public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAllele allele) {
+
+        if (allele == null) {
+            return;
+        }
+
+        if (!chromosomeType.getAlleleClass().isInstance(allele)) {
+            return;
+        }
+
+        // uncomment this once all addon mods are using the allele registration with IChromosomeType
+        //		Collection<IChromosomeType> validTypes = AlleleManager.alleleRegistry.getChromosomeTypes(allele);
+        //		if (validTypes.size() > 0 && !validTypes.contains(chromosomeType)) {
+        //			throw new IllegalArgumentException("Allele can't applied to this Chromosome type. Expected: " + validTypes + " Got: " + chromosomeType);
+        //		}
+
+        alleles[chromosomeType.ordinal()] = allele;
+    }
+
+    @Override
+    public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAlleleValue value) {
+        set(alleles, chromosomeType, get(value));
+    }
+
+    @Override
+    public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, boolean value) {
+        set(alleles, chromosomeType, get(value));
+    }
+
+    @Override
+    public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, int value) {
+        set(alleles, chromosomeType, get(value));
+    }
+
+    private IAllele get(Object value) {
+        Class<?> valueClass = value.getClass();
+        Map<?, ? extends IAllele> map = alleleMaps.get(valueClass);
+        if (map == null) {
+            throw new IllegalArgumentException("There is no IAllele type for: " + valueClass + ' ' + value);
+        }
+        IAllele allele = map.get(value);
+        if (allele == null) {
+            allele = new IAllele() {
+                @Override
+                public String getUID() {
+                    return "NOT_FOUND";
+                }
+
+                @Override
+                public boolean isDominant() {
+                    return false;
+                }
+
+                @Override
+                public String getName() {
+                    return "NOT_FOUND";
+                }
+
+                @Override
+                public String getUnlocalizedName() {
+                    return "NOT_FOUND";
+                }
+            };
+        }
+        return allele;
+    }
+
+    private <K extends Enum<K> & IAlleleValue<V>, V> void createAlleles(Class<K> enumClass, IChromosomeType... types) {
+        String category = enumClass.getSimpleName().toLowerCase(Locale.ENGLISH);
+        EnumMap<K, IAllele> map = new EnumMap<>(enumClass);
+        for (K enumValue : enumClass.getEnumConstants()) {
+            IAllele allele = createAllele(category, enumValue, types);
+            map.put(enumValue, allele);
+        }
+        alleleMaps.put(enumClass, map);
+    }
+    private static <K extends IAlleleValue<V>, V> IAllele createAllele(String category, K enumValue, IChromosomeType... types) {
+        V value = enumValue.getValue();
+        boolean isDominant = enumValue.isDominant();
+        String name = enumValue.toString().toLowerCase(Locale.ENGLISH);
+
+        Class<?> valueClass = value.getClass();
+        if (Float.class.isAssignableFrom(valueClass)) {
+            return AlleleManager.alleleFactory.createFloat(modId, category, name, (Float) value, isDominant, types);
+        } else if (Integer.class.isAssignableFrom(valueClass)) {
+            return AlleleManager.alleleFactory.createInteger(modId, category, name, (Integer) value, isDominant, types);
+        } else if (IVect.class.isAssignableFrom(valueClass)) {
+            IVect area = (IVect) value;
+            return AlleleManager.alleleFactory.createArea(modId, category, name, area.getX(), area.getY(), area.getZ(), isDominant, types);
+        } else if (Boolean.class.isAssignableFrom(valueClass)) {
+            return AlleleManager.alleleFactory.createBoolean(modId, category, (Boolean) value, isDominant, types);
+        } else if (EnumTolerance.class.isAssignableFrom(valueClass)) {
+            IAlleleTolerance alleleTolerance = new AlleleTolerance(modId, category, name, (EnumTolerance) value, isDominant);
+            AlleleManager.alleleRegistry.registerAllele(alleleTolerance, types);
+            return alleleTolerance;
+        } else if (FlowerProvider.class.isAssignableFrom(valueClass)) {
+            return AlleleManager.alleleFactory.createFlowers(modId, category, name, (FlowerProvider) value, isDominant, types);
+        }
+        throw new RuntimeException("could not create allele for category: " + category + " and value " + valueClass);
+    }
+}
diff --git a/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java b/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java
new file mode 100644
index 0000000000..852f00e6d6
--- /dev/null
+++ b/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java
@@ -0,0 +1,75 @@
+package gregtech.common.bees;
+
+import forestry.api.apiculture.*;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IGenome;
+import forestry.api.genetics.IMutationCondition;
+import forestry.apiculture.genetics.BeeMutation;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.world.World;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+
+public class GT_Bee_Mutation extends BeeMutation {
+
+    private int split = 1;
+
+    public GT_Bee_Mutation(IAlleleBeeSpecies bee0, IAlleleBeeSpecies bee1, IAllele[] result, int chance, int split) {
+        super(bee0, bee1, result, chance);
+        this.split = split;
+        BeeManager.beeRoot.registerMutation(this);
+    }
+
+    @Override
+    public float getBaseChance() {
+        return ((float) ((float)super.getBaseChance() / ((float)split)));
+    }
+
+    @Override
+    public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IBeeGenome genome0, IBeeGenome genome1) {
+        World world = housing.getWorld();
+        ChunkCoordinates housingCoordinates = housing.getCoordinates();
+        int x = housingCoordinates.posX;
+        int y = housingCoordinates.posY;
+        int z = housingCoordinates.posZ;
+
+        float processedChance = getbasicChance(world, x, y, z, allele0, allele1, genome0, genome1);
+
+
+        if (processedChance <= 0f) {
+            return 0f;
+        }
+
+        IBeeModifier beeHousingModifier = BeeManager.beeRoot.createBeeHousingModifier(housing);
+        IBeeModifier beeModeModifier = BeeManager.beeRoot.getBeekeepingMode(world).getBeeModifier();
+
+        processedChance *= beeHousingModifier.getMutationModifier(genome0, genome1, processedChance);
+        processedChance *= beeModeModifier.getMutationModifier(genome0, genome1, processedChance);
+
+        return processedChance;
+    }
+
+    protected float getbasicChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
+        float mutationChance = getBaseChance();
+        List<IMutationCondition> mutationConditions = null;
+        try {
+            Field f = this.getClass().getDeclaredField("mutationConditions");
+            f.setAccessible(true);
+            Object o = f.get(this);
+            mutationConditions = o instanceof List ? (List) o : null ;
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        if (mutationConditions != null)
+        for (IMutationCondition mutationCondition : mutationConditions) {
+            mutationChance *= mutationCondition.getChance(world, x, y, z, allele0, allele1, genome0, genome1);
+            if (mutationChance == 0) {
+                return 0;
+            }
+        }
+        return mutationChance;
+    }
+}
diff --git a/src/main/java/gregtech/common/items/CombType.java b/src/main/java/gregtech/common/items/CombType.java
index ffde997fb9..9ff5eb359c 100644
--- a/src/main/java/gregtech/common/items/CombType.java
+++ b/src/main/java/gregtech/common/items/CombType.java
@@ -4,63 +4,206 @@ import gregtech.api.enums.Materials;
 import gregtech.api.util.GT_LanguageManager;
 
 public enum CombType {
-    //Organic
+    //Organic Line
     LIGNIE("lignite", true, Materials.Lignite, 100),
     COAL("coal", true, Materials.Coal, 100),
     STICKY("stickyresin", true, Materials._NULL, 50),
     OIL("oil", true, Materials._NULL, 100),
+    APATITE("apatite", true, Materials.Apatite, 100),
+    ASH("ash", true, Materials.Ash, 100),
+
+    //IC2 Line
+    COOLANT("coolant", true, Materials._NULL, 100),
+    ENERGY("energy", true, Materials._NULL, 80),
+    LAPOTRON("lapotron", true, Materials._NULL, 60),
+    PYROTHEUM("pyrotheum", true, Materials.Pyrotheum, 50),
+    CRYOTHEUM("cryotheum", true, Materials.Pyrotheum, 50),
+
+    //Alloy Line
+    REDALLOY("redalloy", true, Materials.RedAlloy, 100),
+    REDSTONEALLOY("redstonealloy", true, Materials.RedstoneAlloy, 90),
+    CONDUCTIVEIRON("conductiveiron", true, Materials.ConductiveIron, 80),
+    VIBRANTALLOY("vibrantalloy", true, Materials.VibrantAlloy, 50),
+    ENERGETICALLOY("energeticalloy", true, Materials.EnergeticAlloy, 70),
+    ELECTRICALSTEEL("electricalsteel", true, Materials.ElectricalSteel, 90),
+    DARKSTEEL("darksteel", true, Materials.DarkSteel, 80),
+    PULSATINGIRON("pulsatingiron", true, Materials.PulsatingIron, 80),
+    STAINLESSSTEEL("stainlesssteel", true, Materials.StainlessSteel, 75),
+    ENDERIUM("enderium", true, Materials.Enderium, 40),
+
+    //Thaumcraft Line
+    THAUMIUMDUST("thaumiumdust", true, Materials.Thaumium, 100),
+    THAUMIUMSHARD("thaumiumshard", true, Materials._NULL, 85),
+    AMBER("amber", true, Materials.Amber, 90),
+    QUICKSILVER("quicksilver", true, Materials.Mercury, 90),
+    SALISMUNDUS("salismundus", true, Materials._NULL, 75),
+    TAINTED("tainted", true, Materials._NULL, 80),
+    MITHRIL("mithril", true, Materials.Mithril, 70),
+    ASTRALSILVER("astralsilver", true, Materials.AstralSilver, 70),
+    THAUMINITE("thauminite", true, Materials._NULL, 50),
+    SHADOWMETAL("shadowmetal", true, Materials.Shadow, 50),
+    DIVIDED("divided", true, Materials.Unstable, 40),
+    SPARKELING("sparkeling", true, Materials.NetherStar, 40),
+
     //Gem Line
     STONE("stone", true, Materials._NULL, 70),
     CERTUS("certus", true, Materials.CertusQuartz, 100),
+    FLUIX("fluix", true, Materials.Fluix, 100),
     REDSTONE("redstone", true, Materials.Redstone, 100),
+    RAREEARTH("rareearth", true, Materials.RareEarth, 100),
     LAPIS("lapis", true, Materials.Lapis, 100),
     RUBY("ruby", true, Materials.Ruby, 100),
+    REDGARNET("redgarnet", true, Materials.GarnetRed,100),
+    YELLOWGARNET("yellowgarnet", true, Materials.GarnetYellow,100),
     SAPPHIRE("sapphire", true, Materials.Sapphire, 100),
     DIAMOND("diamond", true, Materials.Diamond, 100),
     OLIVINE("olivine", true, Materials.Olivine, 100),
     EMERALD("emerald", true, Materials.Emerald, 100),
+    PYROPE("pyrope", true, Materials.Pyrope, 100),
+    GROSSULAR("grossular", true, Materials.Grossular, 100),
+    FIRESTONE("firestone", true, Materials.Firestone, 100),
 
-    // Metals Line
+    //Metals Line
     SLAG("slag", true, Materials._NULL, 50),
-    COPPER("coppon", true, Materials.Copper, 100),
-    TIN("tine", true, Materials.Tin, 100),
-    LEAD("plumbilia", true, Materials.Lead, 100),
-    IRON("ferru", true, Materials.Iron, 100),
-    STEEL("steeldust", true, Materials.Steel, 100),
-    NICKEL("nickeldust", true, Materials.Nickel, 100),
-    ZINC("galvania", true, Materials.Zinc, 100),
-    SILVER("argentia", true, Materials.Silver, 100),
-    GOLD("aurelia", true, Materials.Gold, 100),
-
-    // Rare Metals Line    
-    ALUMINIUM("bauxia", true, Materials.Aluminium, 60),
-    MANGANESE("pyrolusium", true, Materials.Manganese, 30),
+    COPPER("copper", true, Materials.Copper, 100),
+    TIN("tin", true, Materials.Tin, 100),
+    LEAD("lead", true, Materials.Lead, 100),
+    IRON("iron", true, Materials.Iron, 100),
+    STEEL("steel", true, Materials.Steel, 95),
+    NICKEL("nickel", true, Materials.Nickel, 100),
+    ZINC("zinc", true, Materials.Zinc, 100),
+    SILVER("silver", true, Materials.Silver, 100),
+    GOLD("gold", true, Materials.Gold, 100),
+    SULFUR("sulfur", true, Materials.Sulfur, 100),
+    GALLIUM ("gallium", true, Materials.Gallium, 75),
+    ARSENIC ("arsenic", true, Materials.Arsenic, 75),
+
+    //Rare Metals Line
+    BAUXITE("bauxite", true, Materials.Bauxite, 85),
+    ALUMINIUM("aluminium", true, Materials.Aluminium, 60),
+    MANGANESE("manganese", true, Materials.Manganese, 30),
+    MAGNESIUM("magnesium", true, Materials.Magnesium, 75),
     TITANIUM("titanium", true, Materials.Ilmenite, 100),
     CHROME("chromium", true, Materials.Chrome, 50),
-    TUNGSTEN("scheelinium", true, Materials.Tungstate, 100),
-    PLATINUM("platina", true, Materials.Platinum, 40),
-    IRIDIUM("quantaria", true, Materials.Iridium, 20),
+    TUNGSTEN("tungsten", true, Materials.Tungstate, 100),
+    PLATINUM("platinum", true, Materials.Platinum, 40),
+    IRIDIUM("iridium", true, Materials.Iridium, 20),
+    MOLYBDENUM("molybdenum", true, Materials.Molybdenum, 20),
+    OSMIUM("osmium", true, Materials.Osmium, 15),
+    LITHIUM("lithium", true, Materials.Lithium, 75),
+    SALT("salt", true, Materials.Salt, 90),
+    ELECTROTINE("electrotine", true, Materials.Electrotine, 75),
+    ALMANDINE("almandine", true, Materials.Almandine, 85),
 
-
-    // Radioactive Line
-    URANIUM("urania", true, Materials.Uranium, 50),
+    //Radioactive Line
+    URANIUM("uranium", true, Materials.Uranium, 50),
     PLUTONIUM("plutonium", true, Materials.Plutonium, 10),
-    NAQUADAH("stargatium", true, Materials.Naquadah, 10),;
+    NAQUADAH("naquadah", true, Materials.Naquadah, 10),
+    NAQUADRIA("naquadria", true, Materials.Naquadria, 5),
+    DOB("d-o-b", true, Materials._NULL, 50),
+    THORIUM("thorium", true, Materials.Thorium, 75),
+    LUTETIUM("lutetium", true, Materials.Lutetium, 10),
+    AMERICUM("americum", true, Materials.Americium, 5),
+    NEUTRONIUM("neutronium", true, Materials.Neutronium, 2),
+
+    //Twilight
+    NAGA("naga", true, Materials._NULL, 100),
+    LICH("lich", true, Materials._NULL, 90),
+    HYDRA("hydra", true, Materials._NULL, 80),
+    URGHAST("urghast", true, Materials._NULL, 70),
+    SNOWQUEEN("snowqueen", true, Materials._NULL, 60),
+
+    //Space
+    SPACE("space", true, Materials._NULL, 100),
+    METEORICIRON("meteoriciron",true, Materials.MeteoricIron, 100),
+    DESH("desh",true, Materials.Desh, 90),
+    LEDOX("ledox",true, Materials.Ledox, 75),
+    CALLISTOICE("callistoice",true, Materials.CallistoIce, 75),
+    MYTRYL("mytryl",true, Materials.Mytryl, 65),
+    QUANTIUM("quantium",true, Materials.Quantium, 50),
+    ORIHARUKON("oriharukon",true, Materials.Oriharukon, 50),
+    MYSTERIOUSCRYSTAL("mysteriouscrystal",true, Materials.MysteriousCrystal, 45),
+    BLACKPLUTONIUM("blackplutonium",true, Materials.Quantium, 25),
+    TRINIUM("trinium",true, Materials.Trinium, 25),
+
+    //Planet
+    MERCURY("mercury", true, Materials._NULL, 65),
+    VENUS("venus",true, Materials._NULL, 65),
+    MOON("moon",true, Materials._NULL, 90),
+    MARS("mars",true, Materials._NULL, 80),
+    JUPITER("jupiter",true, Materials._NULL, 75),
+    SATURN("saturn",true, Materials._NULL, 55),
+    URANUS("uranus",true, Materials._NULL, 45),
+    NEPTUN("neptun",true, Materials._NULL, 35),
+    PLUTO("pluto",true, Materials._NULL, 25),
+    HAUMEA("haumea",true, Materials._NULL, 20),
+    MAKEMAKE("makemake",true, Materials._NULL, 20),
+    CENTAURI("centauri",true, Materials._NULL, 15),
+    TCETI("tceti",true, Materials._NULL, 10),
+    BARNARDA("barnarda",true, Materials._NULL, 10),
+    VEGA("vega",true, Materials._NULL, 10),
+
+    //Infinity
+    COSMICNEUTRONIUM("cosmicneutronium",true, Materials._NULL, 5),
+    INFINITYCATALYST("infinitycatalyst",true, Materials._NULL, 2),
+    INFINITY("infinity",true, Materials._NULL, 1);
 
     private static int[][] colours = new int[][]{
-            {0x906237, 0x58300B},
-            {0x666666, 0x525252},
+            //organic
+            {0x58300B, 0x906237},
+            {0x525252, 0x666666},
             {0x2E8F5B, 0xDCC289},
-            {0x4C4C4C, 0x333333},
+            {0x333333, 0x4C4C4C},
+            {0xc1c1f6, 0x676784},
+            {0x1e1a18, 0xc6c6c6},
+            //ic2
+            {0x144F5A, 0x2494A2},
+            {0xC11F1F, 0xEBB9B9},
+            {0x1414FF, 0x6478FF},
+            {0xffebc4, 0xe36400},
+            {0x2660ff, 0x5af7ff},
+            //alloy
+            {0xE60000, 0xB80000},
+            {0xB80000, 0xA50808},
+            {0x817671, 0xCEADA3},
+            {0x86A12D, 0xC4F2AE},
+            {0xFF9933, 0xFFAD5C},
+            {0x787878, 0xD8D8D8},
+            {0x252525, 0x443B44},
+            {0x006600, 0x6DD284},
+            {0x778899, 0xC8C8DC},
+            {0x2E8B57, 0x599087},
+            //Thaumcraft
+            {0x7A007A, 0x5C005C},
+            {0x9966FF, 0xAD85FF},
+            {0x774B15, 0xEE7700},
+            {0xc7c7ea, 0xb5b3df},
+            {0xF7ADDE, 0x592582},
+            {0x904BB8, 0xE800FF},
+            {0xF0E68C, 0xFFFFD2},
+            {0xAFEEEE, 0xE6E6FF},
+            {0x2E2D79, 0x7581E0},
+            {0x100322, 0x100342},
+            {0xF0F0F0, 0xDCDCDC},
+            {0x7A007A, 0xFFFFFF},
+            //gems
             {0x808080, 0x999999},
             {0x57CFFB, 0xBBEEFF},
+            {0xA375FF, 0xB591FF},
             {0x7D0F0F, 0xD11919},
+            {0x555643, 0x343428},
             {0x1947D1, 0x476CDA},
             {0xE6005C, 0xCC0052},
+            {0xBD4C4C, 0xECCECE},
+            {0xA3A341, 0xEDEDCE},
             {0x0033CC, 0x00248F},
             {0xCCFFFF, 0xA3CCCC},
             {0x248F24, 0xCCFFCC},
             {0x248F24, 0x2EB82E},
+            {0x763162, 0x8B8B8B},
+            {0x9B4E00, 0x8B8B8B},
+            {0xC00000, 0xFF0000},
+            //Metals
             {0xD4D4D4, 0x58300B},
             {0xFF6600, 0xE65C00},
             {0xD4D4D4, 0xDDDDDD},
@@ -71,16 +214,73 @@ public enum CombType {
             {0xF0DEF0, 0xF2E1F2},
             {0xC2C2D6, 0xCECEDE},
             {0xE6B800, 0xCFA600},
+            {0x6F6F01, 0x8B8B8B},
+            {0x8B8B8B, 0xC5C5E4},
+            {0x736C52, 0x292412},
+            //Rare Metals
+            {0x6B3600, 0x8B8B8B},
             {0x008AB8, 0xD6D6FF},
             {0xD5D5D5, 0xAAAAAA},
+            {0xF1D9D