/**
* Copyright (c) 2011-2015, 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 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-2015");
BCLog.logger.info("http://www.mod-buildcraft.com");
new BCCreativeTab("main");
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();
}
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);
}
@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());
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);
}
}
}