public class AgricultureConfigHandler
{
    private static Configuration configuration;
    public static boolean EXTRA_TOOLTIPS = false;

    public static boolean generates(String name)
    {
        boolean b = configuration.get("Generators", name, true).getBoolean(true);

        saveChanges();

        return b;
    }

    private static boolean getBoolean(String categories, String key, boolean defaultValue)
    {
        boolean b = configuration.get(categories, key, defaultValue).getBoolean(defaultValue);

        saveChanges();

        return b;
    }

    @Deprecated
    public static int getItem(String itemName, int defaultid)
    {
        return defaultid;
    }

    @Deprecated
    public static int getItem(String category, String itemName, Integer defaultid)
    {
        return defaultid;
    }

    private static String getName(String categories, String key, String defaultValue)
    {
        String string = configuration.get(categories, key, defaultValue).toString();

        saveChanges();

        return string;
    }

    public static boolean itemEnabled(String itemName)
    {
        boolean b = configuration.get("Items", itemName, true).getBoolean(true);

        saveChanges();
        return b;
    }

    public static boolean regen()
    {
        return getBoolean("World_Regen", "regen", false);
    }

    public static String regenKey()
    {
        return getName("World_Regen", "regen_key", "DEFAULT");
    }

    private static void saveChanges()
    {

        if (configuration.hasChanged())
        {
            configuration.save();
        }
    }

    public static boolean setEnabled(String setName)
    {
        boolean b = configuration.get("Sets", setName, true).getBoolean(true);

        saveChanges();

        return b;
    }

    public static void setFile(File file)
    {
        configuration = new Configuration(file);

        configuration.load();

        EXTRA_TOOLTIPS = configuration.getBoolean("extra_tooltips", "debug", EXTRA_TOOLTIPS, "Adds named ID and OreDic names to the Item's Tool tip in advance mode (F3 + h)");
        saveChanges();
    }
} public class AgricultureEventHandler
{
    @SubscribeEvent
    public void displayItemTooltip(ItemTooltipEvent event)
    {
        if (!event.showAdvancedItemTooltips || !AgricultureConfigHandler.EXTRA_TOOLTIPS)
            return;
        
        UniqueIdentifier uid;
        if (event.itemStack.getItem() instanceof ItemBlock)
        {
            Block block = Block.getBlockFromItem(event.itemStack.getItem());
            uid = GameRegistry.findUniqueIdentifierFor(block);
        }
        else 
        {
            uid = GameRegistry.findUniqueIdentifierFor(event.itemStack.getItem());
        }
       
        
        event.toolTip.add(StatCollector.translateToLocal("tooltip.agriculture.namedId") + ": " + uid.toString());
        int [] oreIds = OreDictionary.getOreIDs(event.itemStack);
        if (oreIds.length > 0)
        {
            event.toolTip.add(StatCollector.translateToLocal("tooltip.agriculture.oredic") + ":");
            for (int oreId : oreIds)
            {
                event.toolTip.add(EnumChatFormatting.ITALIC + " " + OreDictionary.getOreName(oreId) + EnumChatFormatting.RESET);
            }
        }
    }
} public class AgricultureLogHandler
{
    private static Logger LOGGER;
    
    public static void setLogger(Logger log)
    {
        LOGGER = log;
    }
    
    public static void info(String message)
    {
        LOGGER.info(message);
    }
    
    public static void trace(String message)
    {
        LOGGER.trace(message);
    }
    
    public static void warn(String message)
    {
        LOGGER.warn(message);
    }
    
} public class GuiHandler implements IGuiHandler
{

    @Override
    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
    {
        TileEntity tileEntity = world.getTileEntity(x, y, z);
        if (tileEntity == null || !((tileEntity instanceof TileEntityBaseMachine))) return null;

        switch (ID)
        {
            case GuiIds.BREWER:
                return new ContainerBrewer(player.inventory, (TileEntityBrewer) tileEntity);
            case GuiIds.CABINET:
                return new ContainerCabinet(player.inventory, (TileEntityCounter) tileEntity);
            case GuiIds.COUNTER:
                return new ContainerCounter(player.inventory, (TileEntityBaseMachine) tileEntity);
            case GuiIds.FRIER:
                return new ContainerFrier(player.inventory, (TileEntityFrier) tileEntity);
            case GuiIds.FUEL:
                return new ContainerFuel(player.inventory, (TileEntityBaseMachine) tileEntity);
            case GuiIds.ICEBOX:
                return new ContainerIcebox(player.inventory, (TileEntityIcebox) tileEntity);
            case GuiIds.OVEN:
                return new ContainerOven(player.inventory, (TileEntityOven) tileEntity);
            case GuiIds.PROCESSOR:
                return new ContainerProcessor(player.inventory, (TileEntityProcessor) tileEntity);
            default:
                return null;
        }
    }

    @Override
    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
    {
        TileEntity tileEntity = world.getTileEntity(x, y, z);
        if (tileEntity == null || !((tileEntity instanceof TileEntityBaseMachine))) return null;

        switch (ID)
        {
            case GuiIds.BREWER:
                return new GuiBrewer(new ContainerBrewer(player.inventory, (TileEntityBrewer) tileEntity));
            case GuiIds.CABINET:
                return new GuiCabinet(new ContainerCabinet(player.inventory, (TileEntityCounter) tileEntity));
            case GuiIds.COUNTER:
                return new GuiCounter(new ContainerCounter(player.inventory, (TileEntityBaseMachine) tileEntity));
            case GuiIds.FRIER:
                return new GuiFrier(new ContainerFrier(player.inventory, (TileEntityFrier) tileEntity));
            case GuiIds.FUEL:
                return new GuiFuel(new ContainerFuel(player.inventory, (TileEntityBaseMachine) tileEntity));
            case GuiIds.ICEBOX:
                return new GuiIcebox(new ContainerIcebox(player.inventory, (TileEntityIcebox) tileEntity));
            case GuiIds.OVEN:
                return new GuiOven(new ContainerOven(player.inventory, (TileEntityOven) tileEntity));
            case GuiIds.PROCESSOR:
                return new GuiProcessor(new ContainerProcessor(player.inventory, (TileEntityProcessor) tileEntity));
            default:
                return null;
        }
    }
} public class MissingMapHandler
{
    public static void processingMissingMap(FMLMissingMappingsEvent event)
    {
        List<MissingMapping> missingMappings = event.get();
        for (MissingMapping map : missingMappings)
        {
            if (map.name.equals("Agriculture:base.crop"))
            {
                ItemStack stack = ItemList.getItemStack("base", "Dough");
                map.remap(stack.getItem());
            }
        }
    }
} public class Hunger
{
    public static void init()
    {
        // TODO: Rework
    }
} public class CommonProxy
{

    public void initRenderers()
    {
        // only client
    }

} public class Recipes
{
    private static HashMap<String, String> predefinedOreDicNames = new HashMap<String, String>();
    private static ArrayList<RecipeBrewer> brewerRecipes = new ArrayList<RecipeBrewer>();
    private static ArrayList<RecipeCoolent> coolentRecipes = new ArrayList<RecipeCoolent>();
    private static ArrayList<RecipeCounter> counterRecipes = new ArrayList<RecipeCounter>();
    private static ArrayList<RecipeFrier> frierRecipes = new ArrayList<RecipeFrier>();
    private static ArrayList<RecipeIceBox> iceBoxRecipes = new ArrayList<RecipeIceBox>();
    private static ArrayList<RecipeOven> ovenRecipes = new ArrayList<RecipeOven>();
    private static ArrayList<RecipeProcessor> processorRecipes = new ArrayList<RecipeProcessor>();

    public static void create()
    {
        initPredefinedOreDicNames();

        String[] setNames = ItemList.getSetNames();
        for (String setName : setNames)
        {
            FoodSet foodSet = ItemList.getSet(setName);

            Food[] foods = foodSet.getFoods();

            for (Food food : foods)
            {
                if (food != null)
                {
                    if (food.method != null)
                    {
                        addOreDicRecipe(foodSet, food);
                    }
                }
                else
                {
                    AgricultureLogHandler.warn("issue with food");
                }
            }
        }

        AgricultureLogHandler.trace("Finished creating recipes");
    }

    private static void addOreDicRecipe(FoodSet foodSet, Food food)
    {
        String[] ingredientsOreDic = new String[food.recipe.length];

        for (int i = 0; i < ingredientsOreDic.length; i++)
        {
            Food ingredient = foodSet.getFoodInfo(food.recipe[i]);

            if (ingredient != null)
            {
                // Found a set ingredient

                String tag = ingredient.getName().replace(" ", "");

                String oreDicPrefix = "crop";

                if (ingredient.type == FoodType.base || ingredient.type == FoodType.edible)
                {
                    oreDicPrefix = "food";
                }

                ingredientsOreDic[i] = oreDicPrefix + tag;
                continue;
            }

            // Find from predefined
            String oreDicName = getPredefinedOreDicName(food.recipe[i]);
            if (oreDicName != null)
            {
                ingredientsOreDic[i] = oreDicName;
                continue;
            }

            AgricultureLogHandler.info("Couldn't find ingreadiant '" + food.recipe[i] + "' for '" + food.getName() + "'");
            return;
        }

        switch (food.method)
        {
            case bake:
                addOreDicOvenRecipe(foodSet.getItemStack(food.getName()), ingredientsOreDic[0]);
                break;
            case brew:
                break;
            case freeze:
                addOreDicIceBoxRecipe(foodSet.getItemStack(food.getName()), ingredientsOreDic[0]);
                break;
            case fry:
                addOreDicFrierRecipe(foodSet.getItemStack(food.getName()), ingredientsOreDic[0]);
                break;
            case prepare:
                addOreDicCounterRecipe(foodSet.getItemStack(food.getName()), ingredientsOreDic);
                break;
            case process:
                addOreDicProcessRecipe(foodSet.getItemStack(food.getName()), ingredientsOreDic);
                break;
            default:
                break;

        }
    }

    private static void initPredefinedOreDicNames()
    {
        predefinedOreDicNames.put("Carrot", "cropCarrot");
        predefinedOreDicNames.put("Potato", "cropPotato");
        predefinedOreDicNames.put("Stick", "stickWood");
        predefinedOreDicNames.put("Water", "foodCupOfWater");
        predefinedOreDicNames.put("Wheat", "cropWheat");
    }

    public static String getPredefinedOreDicName(String name)
    {
        return predefinedOreDicNames.get(name);
    }

    public static void addBrewerRecipe(String outputFluid, String baseFluid, ItemStack ingredient)
    {
        FluidStack output = FluidRegistry.getFluidStack(outputFluid, FluidContainerRegistry.BUCKET_VOLUME);
        FluidStack base = FluidRegistry.getFluidStack(baseFluid, FluidContainerRegistry.BUCKET_VOLUME);

        if (output != null && base != null)
        {
            brewerRecipes.add(new RecipeBrewer(ingredient, base, output));
        }
    }

    public static void addOreDicBrewerRecipe(String outputFluid, String baseFluid, String ingredient)
    {
        FluidStack output = FluidRegistry.getFluidStack(outputFluid, FluidContainerRegistry.BUCKET_VOLUME);
        FluidStack base = FluidRegistry.getFluidStack(baseFluid, FluidContainerRegistry.BUCKET_VOLUME);
        ArrayList<ItemStack> ingredientList = OreDictionary.getOres(ingredient);

        if (output != null && base != null && ingredientList != null && ingredientList.size() > 0)
        {
            ItemStack[] ingredients = ingredientList.toArray(new ItemStack[ingredientList.size()]);
            brewerRecipes.add(new RecipeBrewer(ingredients, base, output));
        }
    }

    public static void addCoolentRecipe(ItemStack coolent, int ticks, int temp)
    {
        coolentRecipes.add(new RecipeCoolent(coolent, ticks, temp));
    }

    public static void addOreDicCoolentRecipe(String coolent, int ticks, int temp)
    {
        ArrayList<ItemStack> coolentList = OreDictionary.getOres(coolent);
        if (coolentList != null && coolentList.size() > 0)
        {
            ItemStack[] coolents = coolentList.toArray(new ItemStack[coolentList.size()]);
            coolentRecipes.add(new RecipeCoolent(coolents, ticks, temp));
        }
    }

    public static void addCounterRecipe(ItemStack output, ItemStack... ingredients)
    {
        counterRecipes.add(new RecipeCounter(output, ingredients));
    }

    public static void addOreDicCounterRecipe(ItemStack output, String... ingredients)
    {
        ArrayList<ArrayList<ItemStack>> allIngredientsList = new ArrayList<ArrayList<ItemStack>>();
        for (String ingredient : ingredients)
        {
            ArrayList<ItemStack> ingredientsList = OreDictionary.getOres(ingredient);
            if (ingredientsList == null || ingredientsList.size() <= 0)
            {
                AgricultureLogHandler.warn("Couldn't find oredic ingredient '" + ingredient + "' for " + output.getUnlocalizedName() + " counter recipe, skipping...");
                return;
            }
            allIngredientsList.add(ingredientsList);
        }

        counterRecipes.add(new RecipeCounter(output, allIngredientsList));
    }

    public static RecipeCounter[] getCounterRecipes()
    {
        RecipeCounter[] recipe = new RecipeCounter[counterRecipes.size()];
        recipe = counterRecipes.toArray(recipe);
        return recipe;
    }

    public static void addFrierRecipe(ItemStack output, ItemStack ingredient)
    {
        frierRecipes.add(new RecipeFrier(ingredient, 100, output));
    }

    public static void addOreDicFrierRecipe(ItemStack output, String ingredient)
    {
        ArrayList<ItemStack> ingredientList = OreDictionary.getOres(ingredient);
        if (ingredientList != null && ingredientList.size() > 0)
        {
            ItemStack[] ingredients = ingredientList.toArray(new ItemStack[ingredientList.size()]);
            frierRecipes.add(new RecipeFrier(ingredients, 100, output));
        }
    }

    public static RecipeFrier[] getFrierRecipes()
    {
        RecipeFrier[] recipes = new RecipeFrier[frierRecipes.size()];
        recipes = frierRecipes.toArray(recipes);
        return recipes;
    }

    public static void addIceBoxRecipe(ItemStack output, ItemStack ingredient)
    {
        iceBoxRecipes.add(new RecipeIceBox(ingredient, -10, output));
    }

    public static void addOreDicIceBoxRecipe(ItemStack output, String ingredient)
    {
        ArrayList<ItemStack> ingredientList = OreDictionary.getOres(ingredient);
        if (ingredientList != null && ingredientList.size() > 0)
        {
            ItemStack[] ingredients = ingredientList.toArray(new ItemStack[ingredientList.size()]);
            iceBoxRecipes.add(new RecipeIceBox(ingredients, -10, output));
        }
    }

    public static RecipeIceBox[] getIceboxRecipes()
    {
        RecipeIceBox[] recipes = new RecipeIceBox[iceBoxRecipes.size()];
        recipes = iceBoxRecipes.toArray(recipes);
        return recipes;
    }

    public static void addOvenRecipe(ItemStack output, ItemStack ingredient)
    {
        ovenRecipes.add(new RecipeOven(ingredient, 250, output));
    }

    public static void addOreDicOvenRecipe(ItemStack output, String ingredient)
    {
        ArrayList<ItemStack> ingredientList = OreDictionary.getOres(ingredient);
        if (ingredientList != null && ingredientList.size() > 0)
        {
            ItemStack[] ingredients = ingredientList.toArray(new ItemStack[ingredientList.size()]);
            ovenRecipes.add(new RecipeOven(ingredients, 250, output));
        }
    }

    public static RecipeOven[] getOvenRecipes()
    {
        RecipeOven[] recipes = new RecipeOven[ovenRecipes.size()];
        recipes = ovenRecipes.toArray(recipes);
        return recipes;
    }

    public static void addProcessorRecipe(ItemStack output, ItemStack... ingredients)
    {
        if (ingredients.length == 1 && ingredients[0] != null)
        {
            processorRecipes.add(new RecipeProcessor(ingredients[0], output));
        }
        else if (ingredients.length == 2 && ingredients[0] != null && ingredients[1] != null)
        {
            processorRecipes.add(new RecipeProcessor(ingredients[0], ingredients[1], output));
        }
    }

    public static void addOreDicProcessRecipe(ItemStack output, String... ingredients)
    {
        if (ingredients.length == 1 && ingredients[0] != null)
        {
            ArrayList<ItemStack> oreDicIngredientList = OreDictionary.getOres(ingredients[0]);
            if (oreDicIngredientList != null && oreDicIngredientList.size() > 0)
            {
                ItemStack[] oreDicIngreadient = oreDicIngredientList.toArray(new ItemStack[oreDicIngredientList.size()]);
                processorRecipes.add(new RecipeProcessor(oreDicIngreadient, output));
            }
        }
        else if (ingredients.length == 2 && ingredients[0] != null && ingredients[1] != null)
        {
            ArrayList<ItemStack> oreDicIngredientList1 = OreDictionary.getOres(ingredients[0]);
            ArrayList<ItemStack> oreDicIngredienttList2 = OreDictionary.getOres(ingredients[1]);

            if (oreDicIngredientList1 != null && oreDicIngredientList1.size() > 0 && oreDicIngredienttList2 != null && oreDicIngredienttList2.size() > 0)
            {
                ItemStack[] oreDicIngredient1 = oreDicIngredientList1.toArray(new ItemStack[oreDicIngredientList1.size()]);
                ItemStack[] oreDicIngredient2 = oreDicIngredienttList2.toArray(new ItemStack[oreDicIngredienttList2.size()]);

                processorRecipes.add(new RecipeProcessor(oreDicIngredient1, oreDicIngredient2, output));
            }
        }
    }

    public static ItemStack getProcessorRecipeOutput(ItemStack... ingredents)
    {
        if (ingredents == null || ingredents.length <= 0) return null;

        ItemStack result = null;
        for (RecipeProcessor recipe : processorRecipes)
        {
            if (recipe.isInput(ingredents))
            {
                result = recipe.getOutput();
            }
        }
        return result;

    }

    public static RecipeProcessor[] getProcessorRecipes()
    {
        RecipeProcessor[] recipes = new RecipeProcessor[processorRecipes.size()];
        recipes = processorRecipes.toArray(recipes);
        return recipes;
    }

} public class AgricultureCreativeTab extends CreativeTabs
{
    private ItemStack iconItemStack;

    public AgricultureCreativeTab(String lable)
    {
        super(lable);
    }

    @Override
    public Item getTabIconItem()
    {
        return Items.stick;
    }
    
    @Override
    public ItemStack getIconItemStack()
    {
        if (iconItemStack == null)
        {
            iconItemStack = new ItemStack(getTabIconItem());
        }
        return iconItemStack;
    }
    
    public void setItemStack(ItemStack itemStack)
    {
        iconItemStack = itemStack;
    }
    
    public void setItem(Block block)
    {
        iconItemStack = new ItemStack(block);
    }

} public class WorldGenPlants implements IWorldGenerator
{
    private Block plants[];
    private static long plantGenerationSeed;

    public WorldGenPlants()
    {
        plantGenerationSeed = "agriculture.plants".hashCode();
        plants = new Block[] { BlockList.cinnamon, BlockList.peanut, BlockList.strawberry, BlockList.vanilla };
    }

    @Override
    public void generate(Random fmlRandom, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
    {
        Random random = new Random(((fmlRandom.nextLong() ^ plantGenerationSeed) ^ chunkX) ^ chunkZ);

        if (random.nextInt(100) < 75) return;

        int xPos = (chunkX * 16) + random.nextInt(16);
        int zPos = (chunkZ * 16) + random.nextInt(16);
        int yPos = world.getHeightValue(xPos, zPos) + 32;

        do
        {
            Block block = world.getBlock(xPos, yPos, zPos);
            if (!(block.isLeaves(world, xPos, yPos, zPos) || block.isAir(world, xPos, yPos, zPos)))
            {
                break;
            }
            --yPos;
        } while (yPos > 0);

        yPos++;

        Block blockPlant = plants[random.nextInt(plants.length)];

        int radius = random.nextInt((6 - 4) + 1) + 4;

        for (int i = 0; i < radius; i++)
        {
            for (int j = 0; j < radius; j++)
            {
                if (world.isAirBlock(xPos + i, yPos, zPos + j) && blockPlant.canBlockStay(world, xPos + i, yPos, zPos + j) && random.nextInt(100) > 85)
                {
                    world.setBlock(xPos + i, yPos, zPos + j, blockPlant, 0, 2);
                }
            }

        }

    }

} public class WorldGenSalt implements IWorldGenerator
{
    private int saltPerChunk = 1;
    private Block saltBlock;
    private static int saltSeed = "saltBlock".hashCode();

    public WorldGenSalt()
    {
        saltBlock = BlockList.salt;
    }

    @Override
    public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
    {

        Random chunkRandom = new Random(random.nextLong() + saltSeed);

        for (int i = 0; i < saltPerChunk; i++)
        {
            int randX = chunkX * 16 + chunkRandom.nextInt(16) + 8;
            int randZ = chunkZ * 16 + chunkRandom.nextInt(16) + 8;
            this.generate(world, chunkRandom, randX, world.getTopSolidOrLiquidBlock(randX, randZ), randZ);
        }
    }

    public boolean generate(World world, Random random, int centerX, int centerY, int centerZ)
    {
        if (world.getBlock(centerX, centerY, centerZ).getMaterial() != Material.water)
        {
            return false;
        }
        else
        {
            int raidus = random.nextInt(2) + 2;
            byte heightRaidus = 1;

            for (int posX = centerX - raidus; posX <= centerX + raidus; posX++)
            {
                for (int posZ = centerZ - raidus; posZ <= centerZ + raidus; posZ++)
                {
                    int deltaX = posX - centerX;
                    int deltaZ = posZ - centerZ;

                    if (deltaX * deltaX + deltaZ * deltaZ <= raidus * raidus)
                    {
                        for (int posY = centerY - heightRaidus; posY <= centerY + heightRaidus; posY++)
                        {
                            Block block = world.getBlock(posX, posY, posZ);

                            if (block == Blocks.dirt || block == saltBlock)
                            {
                                world.setBlock(posX, posY, posZ, saltBlock, 0, 2);
                            }
                        }
                    }
                }
            }
            return true;
        }
    }
}
import net.minecraftforge.common.MinecraftForge;
import com.teammetallurgy.agriculture.handler.AgricultureConfigHandler;
import com.teammetallurgy.agriculture.handler.AgricultureEventHandler;
import com.teammetallurgy.agriculture.handler.AgricultureLogHandler;
import com.teammetallurgy.agriculture.handler.GuiHandler;
import com.teammetallurgy.agriculture.handler.MissingMapHandler;
import com.teammetallurgy.agriculture.hunger.Hunger;
import com.teammetallurgy.agriculture.networking.CommonProxy;
import com.teammetallurgy.agriculture.recpies.Recipes;
import com.teammetallurgy.agriculture.utils.AgricultureCreativeTab;
import com.teammetallurgy.agriculture.worldgen.WorldGenPlants;
import com.teammetallurgy.agriculture.worldgen.WorldGenSalt;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLMissingMappingsEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
package com.teammetallurgy.agriculture;




@Mod(name = Agriculture.MODNAME, modid = Agriculture.MODID, version = Agriculture.VERSION, useMetadata = true)
public class Agriculture
{
    public static final String MODNAME = "Agriculture";
    public static final String MODID = "Agriculture";
    public static final String VERSION = "2.0";

    @Mod.Instance(Agriculture.MODID)
    public static Agriculture instance;

    @SidedProxy(clientSide = "com.teammetallurgy.agriculture.networking.ClientProxy", serverSide = "com.teammetallurgy.agriculture.networking.CommonProxy")
    public static CommonProxy proxy;
    

    public AgricultureCreativeTab creativeTabFood = new AgricultureCreativeTab(Agriculture.MODID + ".Food");
    public AgricultureCreativeTab creativeTabBlock = new AgricultureCreativeTab(Agriculture.MODID + ".blocks");

    @EventHandler
    public void preInit(FMLPreInitializationEvent event)
    {
        AgricultureLogHandler.setLogger(event.getModLog());
        AgricultureConfigHandler.setFile(event.getSuggestedConfigurationFile());