buildcraft/common/buildcraft/BuildCraftCore.java

/**
 * Copyright (c) 2011-2017, SpaceToad and the BuildCraft Team
 * http://www.mod-buildcraft.com
 * <p/>
 * BuildCraft is distributed under the terms of the Minecraft Mod Public
 * License 1.0, or MMPL. Please check the contents of the license located in
 * http://www.mod-buildcraft.com/MMPL-1.0.txt
 */
package buildcraft;

import java.io.File;
import java.util.UUID;

import com.mojang.authlib.GameProfile;

import net.minecraft.block.Block;
import net.minecraft.block.BlockLiquid;
import net.minecraft.entity.EntityList;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemFood;
import net.minecraft.item.ItemStack;
import net.minecraft.stats.Achievement;
import net.minecraft.util.IIcon;

import cpw.mods.fml.client.event.ConfigChangedEvent;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLInterModComms;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.event.FMLServerStartingEvent;
import cpw.mods.fml.common.event.FMLServerStoppingEvent;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraftforge.client.event.TextureStitchEvent;
import net.minecraftforge.common.IPlantable;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.world.WorldEvent;
import net.minecraftforge.fluids.BlockFluidBase;
import net.minecraftforge.oredict.OreDictionary;

import buildcraft.api.blueprints.BuilderAPI;
import buildcraft.api.core.BCLog;
import buildcraft.api.core.BuildCraftAPI;
import buildcraft.api.core.EnumColor;
import buildcraft.api.core.IIconProvider;
import buildcraft.api.core.IWorldProperty;
import buildcraft.api.crops.CropManager;
import buildcraft.api.filler.FillerManager;
import buildcraft.api.filler.IFillerPattern;
import buildcraft.api.lists.ListRegistry;
import buildcraft.api.recipes.BuildcraftRecipeRegistry;
import buildcraft.api.statements.IActionExternal;
import buildcraft.api.statements.IActionInternal;
import buildcraft.api.statements.IStatement;
import buildcraft.api.statements.ITriggerExternal;
import buildcraft.api.statements.ITriggerInternal;
import buildcraft.api.statements.StatementManager;
import buildcraft.api.statements.StatementParameterItemStack;
import buildcraft.api.tablet.TabletAPI;
import buildcraft.api.tiles.IControllable;
import buildcraft.core.AchievementManager;
import buildcraft.core.BCCreativeTab;
import buildcraft.core.BCRegistry;
import buildcraft.core.BlockBuildTool;
import buildcraft.core.BlockEngine;
import buildcraft.core.BlockMarker;
import buildcraft.core.BlockPathMarker;
import buildcraft.core.BlockSpring;
import buildcraft.core.CompatHooks;
import buildcraft.core.CoreGuiHandler;
import buildcraft.core.CoreIconProvider;
import buildcraft.core.CoreSiliconRecipes;
import buildcraft.core.DefaultProps;
import buildcraft.core.InterModComms;
import buildcraft.core.ItemDebugger;
import buildcraft.core.ItemGear;
import buildcraft.core.ItemList;
import buildcraft.core.ItemMapLocation;
import buildcraft.core.ItemPaintbrush;
import buildcraft.core.ItemSpring;
import buildcraft.core.ItemWrench;
import buildcraft.core.SchematicEngine;
import buildcraft.core.SpringPopulate;
import buildcraft.core.TickHandlerCore;
import buildcraft.core.TileEngineWood;
import buildcraft.core.TilePathMarker;
import buildcraft.core.Version;
import buildcraft.core.blueprints.BuildingSlotMapIterator;
import buildcraft.core.blueprints.SchematicHelper;
import buildcraft.core.blueprints.SchematicRegistry;
import buildcraft.core.builders.patterns.FillerPattern;
import buildcraft.core.builders.patterns.FillerRegistry;
import buildcraft.core.builders.patterns.PatternBox;
import buildcraft.core.builders.patterns.PatternClear;
import buildcraft.core.builders.patterns.PatternCylinder;
import buildcraft.core.builders.patterns.PatternFill;
import buildcraft.core.builders.patterns.PatternFlatten;
import buildcraft.core.builders.patterns.PatternFrame;
import buildcraft.core.builders.patterns.PatternHorizon;
import buildcraft.core.builders.patterns.PatternParameterCenter;
import buildcraft.core.builders.patterns.PatternParameterHollow;
import buildcraft.core.builders.patterns.PatternParameterXZDir;
import buildcraft.core.builders.patterns.PatternParameterYDir;
import buildcraft.core.builders.patterns.PatternPyramid;
import buildcraft.core.builders.patterns.PatternStairs;
import buildcraft.core.builders.schematics.SchematicIgnore;
import buildcraft.core.command.SubCommandChangelog;
import buildcraft.core.command.SubCommandDeop;
import buildcraft.core.command.SubCommandOp;
import buildcraft.core.command.SubCommandVersion;
import buildcraft.core.config.BuildCraftConfiguration;
import buildcraft.core.config.ConfigManager;
import buildcraft.core.crops.CropHandlerPlantable;
import buildcraft.core.crops.CropHandlerReeds;
import buildcraft.core.lib.commands.RootCommand;
import buildcraft.core.lib.engines.ItemEngine;
import buildcraft.core.lib.engines.TileEngineBase;
import buildcraft.core.lib.network.ChannelHandler;
import buildcraft.core.lib.render.FluidRenderer;
import buildcraft.core.lib.utils.ColorUtils;
import buildcraft.core.lib.utils.NBTUtils;
import buildcraft.core.lib.utils.Utils;
import buildcraft.core.lib.utils.XorShift128Random;
import buildcraft.core.list.ListMatchHandlerArmor;
import buildcraft.core.list.ListMatchHandlerClass;
import buildcraft.core.list.ListMatchHandlerFluid;
import buildcraft.core.list.ListMatchHandlerOreDictionary;
import buildcraft.core.list.ListMatchHandlerTools;
import buildcraft.core.list.ListOreDictionaryCache;
import buildcraft.core.list.ListTooltipHandler;
import buildcraft.core.network.PacketHandlerCore;
import buildcraft.core.properties.WorldPropertyIsDirt;
import buildcraft.core.properties.WorldPropertyIsFarmland;
import buildcraft.core.properties.WorldPropertyIsFluidSource;
import buildcraft.core.properties.WorldPropertyIsHarvestable;
import buildcraft.core.properties.WorldPropertyIsLeaf;
import buildcraft.core.properties.WorldPropertyIsOre;
import buildcraft.core.properties.WorldPropertyIsReplaceable;
import buildcraft.core.properties.WorldPropertyIsShoveled;
import buildcraft.core.properties.WorldPropertyIsSoft;
import buildcraft.core.properties.WorldPropertyIsWood;
import buildcraft.core.proxy.CoreProxy;
import buildcraft.core.recipes.AssemblyRecipeManager;
import buildcraft.core.recipes.IntegrationRecipeManager;
import buildcraft.core.recipes.ProgrammingRecipeManager;
import buildcraft.core.recipes.RefineryRecipeManager;
import buildcraft.core.render.BlockHighlightHandler;
import buildcraft.core.render.RenderLEDTile;
import buildcraft.core.render.RenderLaser;
import buildcraft.core.statements.ActionMachineControl;
import buildcraft.core.statements.ActionRedstoneOutput;
import buildcraft.core.statements.DefaultActionProvider;
import buildcraft.core.statements.DefaultTriggerProvider;
import buildcraft.core.statements.StatementParameterDirection;
import buildcraft.core.statements.StatementParameterItemStackExact;
import buildcraft.core.statements.StatementParameterRedstoneGateSideOnly;
import buildcraft.core.statements.TriggerEnergy;
import buildcraft.core.statements.TriggerFluidContainer;
import buildcraft.core.statements.TriggerFluidContainerLevel;
import buildcraft.core.statements.TriggerInventory;
import buildcraft.core.statements.TriggerInventoryLevel;
import buildcraft.core.statements.TriggerMachine;
import buildcraft.core.statements.TriggerRedstoneInput;
import buildcraft.core.tablet.ItemTablet;
import buildcraft.core.tablet.PacketTabletMessage;
import buildcraft.core.tablet.TabletProgramMenuFactory;
import buildcraft.core.tablet.manager.TabletManagerClient;
import buildcraft.core.tablet.manager.TabletManagerServer;

@Mod(name = "BuildCraft", version = Version.VERSION, useMetadata = false, modid = "BuildCraft|Core", acceptedMinecraftVersions = "[1.7.10,1.8)", dependencies = "required-after:Forge@[10.13.2.1236,)", guiFactory = "buildcraft.core.config.ConfigManager")
public class BuildCraftCore extends BuildCraftMod {
	@Mod.Instance("BuildCraft|Core")
	public static BuildCraftCore instance;

	public static final boolean DEVELOPER_MODE = false;

	public enum RenderMode {
		Full, NoDynamic
	}

	public static RootCommand commandBuildcraft = new RootCommand("buildcraft");
	public static XorShift128Random random = new XorShift128Random();
	public static RenderMode render = RenderMode.Full;
	public static boolean debugWorldgen = false;
	public static boolean modifyWorld = false;
	public static boolean colorBlindMode = false;
	public static boolean hidePowerNumbers = false;
	public static boolean hideFluidNumbers = false;
	public static boolean canEnginesExplode = false;
	public static boolean useServerDataOnClient = true;
	public static boolean alphaPassBugPresent = true;
	public static int itemLifespan = 1200;
	public static int updateFactor = 10;
	public static int builderMaxPerItemFactor = 1024;
	public static long longUpdateFactor = 40;
	public static BuildCraftConfiguration mainConfiguration;
	public static ConfigManager mainConfigManager;

	public static BlockEngine engineBlock;
	public static BlockMarker markerBlock;
	public static BlockPathMarker pathMarkerBlock;
	public static Block springBlock;
	public static BlockBuildTool buildToolBlock;
	public static Item woodenGearItem;
	public static Item stoneGearItem;
	public static Item ironGearItem;
	public static Item goldGearItem;
	public static Item diamondGearItem;
	public static Item wrenchItem;
	public static Item mapLocationItem;
	public static Item debuggerItem;
	public static Item paintbrushItem;
	public static ItemList listItem;
	public static ItemTablet tabletItem;
	@SideOnly(Side.CLIENT)
	public static IIcon redLaserTexture;
	@SideOnly(Side.CLIENT)
	public static IIcon blueLaserTexture;
	@SideOnly(Side.CLIENT)
	public static IIcon stripesLaserTexture;
	@SideOnly(Side.CLIENT)
	public static IIcon transparentTexture;
	@SideOnly(Side.CLIENT)
	public static IIconProvider iconProvider;
	public static int blockByEntityModel;
	public static int complexBlockModel;
	public static int markerModel;
	public static ITriggerExternal triggerMachineActive = new TriggerMachine(true);
	public static ITriggerExternal triggerMachineInactive = new TriggerMachine(false);
	public static IStatement triggerEnergyHigh = new TriggerEnergy(true);
	public static IStatement triggerEnergyLow = new TriggerEnergy(false);
	public static ITriggerExternal triggerEmptyInventory = new TriggerInventory(TriggerInventory.State.Empty);
	public static ITriggerExternal triggerContainsInventory = new TriggerInventory(TriggerInventory.State.Contains);
	public static ITriggerExternal triggerSpaceInventory = new TriggerInventory(TriggerInventory.State.Space);
	public static ITriggerExternal triggerFullInventory = new TriggerInventory(TriggerInventory.State.Full);
	public static ITriggerExternal triggerEmptyFluid = new TriggerFluidContainer(TriggerFluidContainer.State.Empty);
	public static ITriggerExternal triggerContainsFluid = new TriggerFluidContainer(TriggerFluidContainer.State.Contains);
	public static ITriggerExternal triggerSpaceFluid = new TriggerFluidContainer(TriggerFluidContainer.State.Space);
	public static ITriggerExternal triggerFullFluid = new TriggerFluidContainer(TriggerFluidContainer.State.Full);
	public static ITriggerInternal triggerRedstoneActive = new TriggerRedstoneInput(true);
	public static ITriggerInternal triggerRedstoneInactive = new TriggerRedstoneInput(false);
	public static ITriggerExternal triggerInventoryBelow25 = new TriggerInventoryLevel(TriggerInventoryLevel.TriggerType.BELOW25);
	public static ITriggerExternal triggerInventoryBelow50 = new TriggerInventoryLevel(TriggerInventoryLevel.TriggerType.BELOW50);
	public static ITriggerExternal triggerInventoryBelow75 = new TriggerInventoryLevel(TriggerInventoryLevel.TriggerType.BELOW75);
	public static ITriggerExternal triggerFluidContainerBelow25 = new TriggerFluidContainerLevel(TriggerFluidContainerLevel.TriggerType.BELOW25);
	public static ITriggerExternal triggerFluidContainerBelow50 = new TriggerFluidContainerLevel(TriggerFluidContainerLevel.TriggerType.BELOW50);
	public static ITriggerExternal triggerFluidContainerBelow75 = new TriggerFluidContainerLevel(TriggerFluidContainerLevel.TriggerType.BELOW75);
	public static IActionInternal actionRedstone = new ActionRedstoneOutput();
	public static IActionExternal[] actionControl;

	public static boolean loadDefaultRecipes = true;
	public static boolean consumeWaterSources = false;
	public static boolean miningAllowPlayerProtectedBlocks = false;
	public static float miningMultiplier;

	public static AchievementManager achievementManager;

	public static Achievement woodenGearAchievement;
	public static Achievement stoneGearAchievement;
	public static Achievement ironGearAchievement;
	public static Achievement goldGearAchievement;
	public static Achievement diamondGearAchievement;
	public static Achievement wrenchAchievement;
	public static Achievement engineRedstoneAchievement;

	public static GameProfile gameProfile = new GameProfile(UUID.nameUUIDFromBytes("buildcraft.core".getBytes()), "[BuildCraft]");

	@Mod.EventHandler
	public void loadConfiguration(FMLPreInitializationEvent evt) {
		BCLog.logger.info("Starting BuildCraft " + Version.getVersion());
		BCLog.logger.info("Copyright (c) the BuildCraft team, 2011-2017");
		BCLog.logger.info("http://www.mod-buildcraft.com");

		commandBuildcraft.addAlias("bc");
		commandBuildcraft.addChildCommand(new SubCommandVersion());
		commandBuildcraft.addChildCommand(new SubCommandChangelog());
		commandBuildcraft.addChildCommand(new SubCommandDeop());
		commandBuildcraft.addChildCommand(new SubCommandOp());

		BuildcraftRecipeRegistry.assemblyTable = AssemblyRecipeManager.INSTANCE;
		BuildcraftRecipeRegistry.integrationTable = IntegrationRecipeManager.INSTANCE;
		BuildcraftRecipeRegistry.refinery = RefineryRecipeManager.INSTANCE;
		BuildcraftRecipeRegistry.programmingTable = ProgrammingRecipeManager.INSTANCE;

		BuilderAPI.schematicHelper = SchematicHelper.INSTANCE;
		BuilderAPI.schematicRegistry = SchematicRegistry.INSTANCE;

		BCRegistry.INSTANCE.setRegistryConfig(new File(evt.getModConfigurationDirectory(), "buildcraft/objects.cfg"));

		mainConfiguration = new BuildCraftConfiguration(new File(evt.getModConfigurationDirectory(), "buildcraft/main.cfg"));
		mainConfigManager = new ConfigManager(mainConfiguration);
		mainConfiguration.load();

		mainConfigManager.getCat("debug").setShowInGui(false);
		mainConfigManager.getCat("vars").setShowInGui(false);

		mainConfigManager.register("general.useServerDataOnClient", BuildCraftCore.useServerDataOnClient, "Allows BuildCraft to use the integrated server's data on the client on singleplayer worlds. Disable if you're getting the odd crash caused by it.", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("general.builderMaxIterationsPerItemFactor", BuildCraftCore.builderMaxPerItemFactor, "Lower this number if BuildCraft builders/fillers are causing TPS lag. Raise it if you think they are being too slow.", ConfigManager.RestartRequirement.NONE);

		mainConfigManager.register("general.miningBreaksPlayerProtectedBlocks", false, "Should BuildCraft miners be allowed to break blocks using player-specific protection?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("general.updateCheck", true, "Should I check the BuildCraft version on startup?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("display.hidePowerValues", false, "Should all power values (RF, RF/t) be hidden?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("display.hideFluidValues", false, "Should all fluid values (mB, mB/t) be hidden?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("general.itemLifespan", 60, "How long, in seconds, should items stay on the ground? (Vanilla = 300, default = 60)", ConfigManager.RestartRequirement.NONE)
				.setMinValue(5);
		mainConfigManager.register("network.updateFactor", 10, "How often, in ticks, should network update packets be sent? Increasing this might help network performance.", ConfigManager.RestartRequirement.GAME)
				.setMinValue(1);
		mainConfigManager.register("network.longUpdateFactor", 40, "How often, in ticks, should full network sync packets be sent? Increasing this might help network performance.", ConfigManager.RestartRequirement.GAME)
				.setMinValue(1);
		mainConfigManager.register("general.canEnginesExplode", false, "Should engines explode upon overheat?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("worldgen.enable", true, "Should BuildCraft generate anything in the world?", ConfigManager.RestartRequirement.GAME);
		mainConfigManager.register("general.pumpsConsumeWater", false, "Should pumps consume water? Enabling this might cause performance issues!", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("power.miningUsageMultiplier", 1.0D, "What should the multiplier of all mining-related power usage be?", ConfigManager.RestartRequirement.NONE);
		mainConfigManager.register("display.colorBlindMode", false, "Should I enable colorblind mode?", ConfigManager.RestartRequirement.GAME);
		mainConfigManager.register("worldgen.generateWaterSprings", true, "Should BuildCraft generate water springs?", ConfigManager.RestartRequirement.GAME);

		reloadConfig(ConfigManager.RestartRequirement.GAME);

		wrenchItem = (new ItemWrench()).setUnlocalizedName("wrenchItem");
		BCRegistry.INSTANCE.registerItem(wrenchItem, false);

		mapLocationItem = (new ItemMapLocation()).setUnlocalizedName("mapLocation");
		BCRegistry.INSTANCE.registerItem(mapLocationItem, false);

		listItem = (ItemList) (new ItemList()).setUnlocalizedName("list");
		BCRegistry.INSTANCE.registerItem(listItem, false);

		debuggerItem = (new ItemDebugger()).setUnlocalizedName("debugger");
		BCRegistry.INSTANCE.registerItem(debuggerItem, false);

		if (BuildCraftCore.modifyWorld) {
			BlockSpring.EnumSpring.WATER.canGen = BuildCraftCore.mainConfigManager.get("worldgen.generateWaterSprings").getBoolean();
			springBlock = new BlockSpring().setBlockName("eternalSpring");
			BCRegistry.INSTANCE.registerBlock(springBlock, ItemSpring.class, false);
		}

		woodenGearItem = (new ItemGear()).setUnlocalizedName("woodenGearItem");
		if (BCRegistry.INSTANCE.registerItem(woodenGearItem, false)) {
			OreDictionary.registerOre("gearWood", new ItemStack(woodenGearItem));
		}

		stoneGearItem = (new ItemGear()).setUnlocalizedName("stoneGearItem");
		if (BCRegistry.INSTANCE.registerItem(stoneGearItem, false)) {
			OreDictionary.registerOre("gearStone", new ItemStack(stoneGearItem));
		}

		ironGearItem = (new ItemGear()).setUnlocalizedName("ironGearItem");
		if (BCRegistry.INSTANCE.registerItem(ironGearItem, false)) {
			OreDictionary.registerOre("gearIron", new ItemStack(ironGearItem));
		}

		goldGearItem = (new ItemGear()).setUnlocalizedName("goldGearItem");
		if (BCRegistry.INSTANCE.registerItem(goldGearItem, false)) {
			OreDictionary.registerOre("gearGold", new ItemStack(goldGearItem));
		}

		diamondGearItem = (new ItemGear()).setUnlocalizedName("diamondGearItem");
		if (BCRegistry.INSTANCE.registerItem(diamondGearItem, false)) {
			OreDictionary.registerOre("gearDiamond", new ItemStack(diamondGearItem));
		}

		paintbrushItem = (new ItemPaintbrush()).setUnlocalizedName("paintbrush");
		BCRegistry.INSTANCE.registerItem(paintbrushItem, false);

		if (DEVELOPER_MODE) {
			tabletItem = new ItemTablet();
			tabletItem.setUnlocalizedName("tablet");
			BCRegistry.INSTANCE.registerItem(tabletItem, false);
		}

		buildToolBlock = new BlockBuildTool();
		buildToolBlock.setBlockName("buildToolBlock");
		BCRegistry.INSTANCE.registerBlock(buildToolBlock, true);

		engineBlock = (BlockEngine) CompatHooks.INSTANCE.getBlock(BlockEngine.class);
		BCRegistry.INSTANCE.registerBlock(engineBlock, ItemEngine.class, true);
		engineBlock.registerTile((Class<? extends TileEngineBase>) CompatHooks.INSTANCE.getTile(TileEngineWood.class), 0, "tile.engineWood", "buildcraftcore:engineWood");
		BCRegistry.INSTANCE.registerTileEntity(TileEngineWood.class, "net.minecraft.src.buildcraft.energy.TileEngineWood");

		markerBlock = (BlockMarker) CompatHooks.INSTANCE.getBlock(BlockMarker.class);
		BCRegistry.INSTANCE.registerBlock(markerBlock.setBlockName("markerBlock"), false);

		pathMarkerBlock = (BlockPathMarker) CompatHooks.INSTANCE.getBlock(BlockPathMarker.class);
		BCRegistry.INSTANCE.registerBlock(pathMarkerBlock.setBlockName("pathMarkerBlock"), false);

		FMLCommonHandler.instance().bus().register(this);
		MinecraftForge.EVENT_BUS.register(this);
		MinecraftForge.EVENT_BUS.register(new BlockHighlightHandler());
		MinecraftForge.EVENT_BUS.register(new ListTooltipHandler());

		OreDictionary.registerOre("chestWood", Blocks.chest);
		OreDictionary.registerOre("craftingTableWood", Blocks.crafting_table);
	}

	@Mod.EventHandler
	public void init(FMLInitializationEvent evt) {
		BuildCraftAPI.proxy = CoreProxy.proxy;

		ChannelHandler coreChannelHandler = new ChannelHandler();
		coreChannelHandler.registerPacketType(PacketTabletMessage.class);

		channels = NetworkRegistry.INSTANCE.newChannel
				(DefaultProps.NET_CHANNEL_NAME + "-CORE", coreChannelHandler, new PacketHandlerCore());

		achievementManager = new AchievementManager("BuildCraft");
		FMLCommonHandler.instance().bus().register(achievementManager);

		woodenGearAchievement = achievementManager.registerAchievement(new Achievement("achievement.woodenGear", "woodenGearAchievement", 0, 0, woodenGearItem, null));
		stoneGearAchievement = achievementManager.registerAchievement(new Achievement("achievement.stoneGear", "stoneGearAchievement", 2, 0, stoneGearItem, woodenGearAchievement));
		ironGearAchievement = achievementManager.registerAchievement(new Achievement("achievement.ironGear", "ironGearAchievement", 4, 0, ironGearItem, stoneGearAchievement));
		goldGearAchievement = achievementManager.registerAchievement(new Achievement("achievement.goldGear", "goldGearAchievement", 6, 0, goldGearItem, ironGearAchievement));
		diamondGearAchievement = achievementManager.registerAchievement(new Achievement("achievement.diamondGear", "diamondGearAchievement", 8, 0, diamondGearItem, goldGearAchievement));
		wrenchAchievement = achievementManager.registerAchievement(new Achievement("achievement.wrench", "wrenchAchievement", 3, 2, wrenchItem, stoneGearAchievement));
		engineRedstoneAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("achievement.redstoneEngine", "engineAchievement1", 1, -2, new ItemStack(engineBlock, 1, 0), BuildCraftCore.woodenGearAchievement));

		// BuildCraft 6.1.4 and below - migration only
		StatementManager.registerParameterClass("buildcraft:stackTrigger", StatementParameterItemStack.class);
		StatementManager.registerParameterClass("buildcraft:stackAction", StatementParameterItemStack.class);

		StatementManager.registerParameterClass(StatementParameterItemStack.class);
		StatementManager.registerParameterClass(StatementParameterItemStackExact.class);
		StatementManager.registerParameterClass(StatementParameterDirection.class);
		StatementManager.registerParameterClass(StatementParameterRedstoneGateSideOnly.class);
		StatementManager.registerTriggerProvider(new DefaultTriggerProvider());
		StatementManager.registerActionProvider(new DefaultActionProvider());

		if (BuildCraftCore.modifyWorld) {
			MinecraftForge.EVENT_BUS.register(new SpringPopulate());
		}

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

		if (BuildCraftCore.loadDefaultRecipes) {
			loadRecipes();
		}

		if (BCCreativeTab.isPresent("main")) {
			BCCreativeTab.get("main").setIcon(new ItemStack(BuildCraftCore.wrenchItem, 1));
		}

		EntityList.stringToClassMapping.remove("BuildCraft|Core.bcLaser");
		EntityList.stringToClassMapping.remove("BuildCraft|Core.bcEnergyLaser");

		BuilderAPI.schematicRegistry.registerSchematicBlock(engineBlock, SchematicEngine.class);

		CoreProxy.proxy.initializeRendering();
		CoreProxy.proxy.initializeEntityRendering();

		NetworkRegistry.INSTANCE.registerGuiHandler(instance, new CoreGuiHandler());

		FMLCommonHandler.instance().bus().register(TabletManagerClient.INSTANCE);
		FMLCommonHandler.instance().bus().register(TabletManagerServer.INSTANCE);
		MinecraftForge.EVENT_BUS.register(TabletManagerClient.INSTANCE);
		MinecraftForge.EVENT_BUS.register(TabletManagerServer.INSTANCE);

		TabletAPI.registerProgram(new TabletProgramMenuFactory());

		// Create filler registry
		try {
			FillerManager.registry = new FillerRegistry();

			// INIT FILLER PATTERNS
			FillerManager.registry.addPattern(PatternFill.INSTANCE);
			FillerManager.registry.addPattern(new PatternFlatten());
			FillerManager.registry.addPattern(new PatternHorizon());
			FillerManager.registry.addPattern(new PatternClear());
			FillerManager.registry.addPattern(new PatternBox());
			FillerManager.registry.addPattern(new PatternPyramid());
			FillerManager.registry.addPattern(new PatternStairs());
			FillerManager.registry.addPattern(new PatternCylinder());
			FillerManager.registry.addPattern(new PatternFrame());
		} catch (Error error) {
			BCLog.logErrorAPI(error, IFillerPattern.class);
			throw error;
		}

		StatementManager.registerParameterClass(PatternParameterYDir.class);
		StatementManager.registerParameterClass(PatternParameterXZDir.class);
		StatementManager.registerParameterClass(PatternParameterCenter.class);
		StatementManager.registerParameterClass(PatternParameterHollow.class);

		ListRegistry.registerHandler(new ListMatchHandlerClass());
		ListRegistry.registerHandler(new ListMatchHandlerFluid());
		ListRegistry.registerHandler(new ListMatchHandlerTools());
		ListRegistry.registerHandler(new ListMatchHandlerArmor());
		ListRegistry.itemClassAsType.add(ItemFood.class);

		if (Loader.isModLoaded("foamfix")) {
			alphaPassBugPresent = false;
		}
	}

	@Mod.EventHandler
	public void postInit(FMLPostInitializationEvent event) {
		BCLog.logger.info("BuildCraft's fake player: UUID = " + gameProfile.getId().toString() + ", name = '" + gameProfile.getName() + "'!");

		BCRegistry.INSTANCE.save();

		for (Object o : Block.blockRegistry) {
			Block block = (Block) o;

			if (block instanceof BlockFluidBase || block instanceof BlockLiquid || block instanceof IPlantable) {
				BuildCraftAPI.softBlocks.add(block);
			}
		}

		BuildCraftAPI.softBlocks.add(Blocks.snow);
		BuildCraftAPI.softBlocks.add(Blocks.vine);
		BuildCraftAPI.softBlocks.add(Blocks.fire);

		FMLCommonHandler.instance().bus().register(new TickHandlerCore());

		CropManager.setDefaultHandler(new CropHandlerPlantable());
		CropManager.registerHandler(new CropHandlerReeds());

		CropHandlerPlantable.forbidBlock(Blocks.reeds);

		BuildCraftAPI.registerWorldProperty("replaceable", new WorldPropertyIsReplaceable());
		BuildCraftAPI.registerWorldProperty("soft", new WorldPropertyIsSoft());
		BuildCraftAPI.registerWorldProperty("wood", new WorldPropertyIsWood());
		BuildCraftAPI.registerWorldProperty("leaves", new WorldPropertyIsLeaf());
		for (int i = 0; i < 4; i++) {
			BuildCraftAPI.registerWorldProperty("ore@hardness=" + i, new WorldPropertyIsOre(i));
		}
		BuildCraftAPI.registerWorldProperty("harvestable", new WorldPropertyIsHarvestable());
		BuildCraftAPI.registerWorldProperty("farmland", new WorldPropertyIsFarmland());
		BuildCraftAPI.registerWorldProperty("shoveled", new WorldPropertyIsShoveled());
		BuildCraftAPI.registerWorldProperty("dirt", new WorldPropertyIsDirt());
		BuildCraftAPI.registerWorldProperty("fluidSource", new WorldPropertyIsFluidSource());

		// Landmarks are often caught incorrectly, making building them counter-productive.
		SchematicRegistry.INSTANCE.registerSchematicBlock(markerBlock, SchematicIgnore.class);
		SchematicRegistry.INSTANCE.registerSchematicBlock(pathMarkerBlock, SchematicIgnore.class);

		ColorUtils.initialize();

		actionControl = new IActionExternal[IControllable.Mode.values().length];
		for (IControllable.Mode mode : IControllable.Mode.values()) {
			if (mode != IControllable.Mode.Unknown && mode != IControllable.Mode.Mode) {
				actionControl[mode.ordinal()] = new ActionMachineControl(mode);
			}
		}

		MinecraftForge.EVENT_BUS.register(ListOreDictionaryCache.INSTANCE);
		for (String s : OreDictionary.getOreNames()) {
			ListOreDictionaryCache.INSTANCE.registerName(s);
		}

		ListRegistry.registerHandler(new ListMatchHandlerOreDictionary());
	}

	@Mod.EventHandler
	public void serverStarting(FMLServerStartingEvent event) {
		event.registerServerCommand(commandBuildcraft);

		/* Increase the builder speed in singleplayer mode.
		   Singleplayer users generally run far fewer of them. */

		if (FMLCommonHandler.instance().getSide() == Side.CLIENT) {
			BuildingSlotMapIterator.MAX_PER_ITEM = builderMaxPerItemFactor * 4;
		} else {
			BuildingSlotMapIterator.MAX_PER_ITEM = builderMaxPerItemFactor;
		}

		if (Utils.CAULDRON_DETECTED) {
			BCLog.logger.warn("############################################");
			BCLog.logger.warn("#                                          #");
			BCLog.logger.warn("#  Cauldron has been detected! Please keep #");
			BCLog.logger.warn("#  in mind that BuildCraft may NOT provide #");
			BCLog.logger.warn("# support to Cauldron users, as the mod is #");
			BCLog.logger.warn("# primarily tested without Bukkit/Spigot's #");
			BCLog.logger.warn("#    changes to the Minecraft internals.   #");
			BCLog.logger.warn("#                                          #");
			BCLog.logger.warn("#  Any lag caused by BuildCraft on top of  #");
			BCLog.logger.warn("#  Cauldron likely arises from workarounds #");
			BCLog.logger.warn("#  which we apply to make sure BuildCraft  #");
			BCLog.logger.warn("#  works properly with Cauldron installed. #");
			BCLog.logger.warn("#                                          #");
			BCLog.logger.warn("#     Thanks for your attention! ~ BC devs #");
			BCLog.logger.warn("#                                          #");
			BCLog.logger.warn("############################################");

			// To people reading that code and thinking we're lying:
			// Cauldron does not invalidate tile entities properly, causing
			// issues with our tile entity cache. That is the bug and that
			// is also the reason for the extra lag caused when using Cauldron.
		}
	}

	@Mod.EventHandler
	public void serverStopping(FMLServerStoppingEvent event) {
		TabletManagerClient.INSTANCE.onServerStopping();
		TabletManagerServer.INSTANCE.onServerStopping();
	}

	@SubscribeEvent
	@SideOnly(Side.CLIENT)
	public void textureHook(TextureStitchEvent.Pre event) {
		for (FillerPattern pattern : FillerPattern.patterns.values()) {
			pattern.registerIcons(event.map);
		}

		if (event.map.getTextureType() == 1) {
			iconProvider = new CoreIconProvider();
			iconProvider.registerIcons(event.map);

			StatementManager.registerIcons(event.map);
		} else if (event.map.getTextureType() == 0) {
			BuildCraftCore.redLaserTexture = event.map.registerIcon("buildcraftcore:laserBox/blockRedLaser");
			BuildCraftCore.blueLaserTexture = event.map.registerIcon("buildcraftcore:laserBox/blockBlueLaser");
			BuildCraftCore.stripesLaserTexture = event.map.registerIcon("buildcraftcore:laserBox/blockStripesLaser");
			BuildCraftCore.transparentTexture = event.map.registerIcon("buildcraftcore:misc/transparent");
			RenderLEDTile.registerBlockIcons(event.map);
		}
	}

	@SubscribeEvent
	@SideOnly(Side.CLIENT)
	public void textureHook(TextureStitchEvent.Post event) {
		FluidRenderer.onTextureReload();
		RenderLaser.onTextureReload();
	}

	public void reloadConfig(ConfigManager.RestartRequirement restartType) {
		if (restartType == ConfigManager.RestartRequirement.GAME) {
			modifyWorld = mainConfigManager.get("worldgen.enable").getBoolean();
			updateFactor = mainConfigManager.get("network.updateFactor").getInt();
			longUpdateFactor = mainConfigManager.get("network.longUpdateFactor").getInt();
			colorBlindMode = mainConfigManager.get("display.colorBlindMode").getBoolean();

			reloadConfig(ConfigManager.RestartRequirement.WORLD);
		} else if (restartType == ConfigManager.RestartRequirement.WORLD) {
			reloadConfig(ConfigManager.RestartRequirement.NONE);
		} else {
			useServerDataOnClient = mainConfigManager.get("general.useServerDataOnClient").getBoolean(true);
			builderMaxPerItemFactor = mainConfigManager.get("general.builderMaxIterationsPerItemFactor").getInt();
			hideFluidNumbers = mainConfigManager.get("display.hideFluidValues").getBoolean();
			hidePowerNumbers = mainConfigManager.get("display.hidePowerValues").getBoolean();
			itemLifespan = mainConfigManager.get("general.itemLifespan").getInt();
			canEnginesExplode = mainConfigManager.get("general.canEnginesExplode").getBoolean();
			consumeWaterSources = mainConfigManager.get("general.pumpsConsumeWater").getBoolean();
			miningMultiplier = (float) mainConfigManager.get("power.miningUsageMultiplier").getDouble();
			miningAllowPlayerProtectedBlocks = mainConfigManager.get("general.miningBreaksPlayerProtectedBlocks").getBoolean();

			BuildingSlotMapIterator.MAX_PER_ITEM = builderMaxPerItemFactor;

			if (miningMultiplier <= 0) {
				throw new RuntimeException("Please do not set the miningMultiplier to values <= 0.0!");
			}

			if (mainConfigManager.get("general.updateCheck").getBoolean(true)) {
				Version.check();
			}

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

	@SubscribeEvent
	public void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
		if ("BuildCraft|Core".equals(event.modID)) {
			reloadConfig(event.isWorldRunning ? ConfigManager.RestartRequirement.NONE : ConfigManager.RestartRequirement.WORLD);
		}
	}

	public void loadRecipes() {
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(wrenchItem), "I I", " G ", " I ", 'I', "ingotIron", 'G', "gearStone");
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(woodenGearItem), " S ", "S S",
				" S ", 'S',
				"stickWood");
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(stoneGearItem), " I ", "IGI",
				" I ", 'I',
				"cobblestone", 'G',
				"gearWood");
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(ironGearItem), " I ", "IGI",
				" I ", 'I',
				"ingotIron", 'G', "gearStone");
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(goldGearItem), " I ", "IGI",
				" I ", 'I',
				"ingotGold", 'G', "gearIron");
		BCRegistry.INSTANCE.addCraftingRecipe(
				new ItemStack(diamondGearItem), " I ", "IGI", " I ", 'I', "gemDiamond", 'G', "gearGold");
		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(mapLocationItem), "ppp", "pYp", "ppp", 'p', Items.paper, 'Y', "dyeYellow");

		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(engineBlock, 1, 0),
				"www", " g ", "GpG", 'w', "plankWood", 'g', "blockGlass", 'G',
				"gearWood", 'p', Blocks.piston);

		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(markerBlock, 1), "l ", "r ", 'l',
				new ItemStack(Items.dye, 1, 4), 'r', Blocks.redstone_torch);

		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(pathMarkerBlock, 1), "l ", "r ", 'l',
				"dyeGreen", 'r', Blocks.redstone_torch);

		BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(paintbrushItem), " iw", " gi", "s  ",
				's', "stickWood", 'g', "gearWood", 'w', new ItemStack(Blocks.wool, 1, 0), 'i', Items.string);

		ItemStack anyPaintbrush = new ItemStack(paintbrushItem, 1, OreDictionary.WILDCARD_VALUE);

		for (int i = 0; i < 16; i++) {
			ItemStack outputStack = new ItemStack(paintbrushItem);
			NBTUtils.getItemData(outputStack).setByte("color", (byte) i);
			BCRegistry.INSTANCE.addShapelessRecipe(outputStack, anyPaintbrush, EnumColor.fromId(i).getDye());
		}

		// Convert old lists to new lists
		BCRegistry.INSTANCE.addShapelessRecipe(new ItemStack(listItem, 1, 1), new ItemStack(listItem, 1, 0));

		if (Loader.isModLoaded("BuildCraft|Silicon")) {
			CoreSiliconRecipes.loadSiliconRecipes();
		} else {
			BCRegistry.INSTANCE.addCraftingRecipe(new ItemStack(listItem, 1, 1), "ppp", "pYp", "ppp", 'p', Items.paper, 'Y',
					"dyeGreen");
		}
	}

	@Mod.EventHandler
	public void processIMCRequests(FMLInterModComms.IMCEvent event) {
		InterModComms.processIMC(event);
	}

	@SubscribeEvent
	public void cleanRegistries(WorldEvent.Unload event) {
		for (IWorldProperty property : BuildCraftAPI.worldProperties.values()) {
			property.clear();
		}
		if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) {
			TilePathMarker.clearAvailableMarkersList(event.world);
		}
	}
}