@Init
  public void load(FMLInitializationEvent evt) {
    NetworkRegistry.instance().registerGuiHandler(instance, new GuiHandler());

    // EntityRegistry.registerModEntity(EntityMechanicalArm.class, "bcMechanicalArm",
    // EntityIds.MECHANICAL_ARM, instance, 50, 1, true);

    CoreProxy.proxy.registerTileEntity(TileQuarry.class, "Machine");
    CoreProxy.proxy.registerTileEntity(TileMiningWell.class, "MiningWell");
    CoreProxy.proxy.registerTileEntity(TileAutoWorkbench.class, "AutoWorkbench");
    CoreProxy.proxy.registerTileEntity(
        TilePump.class, "net.minecraft.src.buildcraft.factory.TilePump");
    CoreProxy.proxy.registerTileEntity(
        TileTank.class, "net.minecraft.src.buildcraft.factory.TileTank");
    CoreProxy.proxy.registerTileEntity(
        TileRefinery.class, "net.minecraft.src.buildcraft.factory.Refinery");

    if (!hopperDisabled) {
      CoreProxy.proxy.registerTileEntity(
          TileHopper.class, "net.minecraft.src.buildcraft.factory.TileHopper");
    }

    FactoryProxy.proxy.initializeTileEntities();

    new BptBlockAutoWorkbench(autoWorkbenchBlock.blockID);
    new BptBlockFrame(frameBlock.blockID);
    new BptBlockRefinery(refineryBlock.blockID);
    new BptBlockTank(tankBlock.blockID);

    if (BuildCraftCore.loadDefaultRecipes) {
      loadRecipes();
    }
  }
  @PreInit
  public void preInit(FMLPreInitializationEvent evt) {
    PHArmory.initProps();
    toolrack = new DisplayBlock(PHArmory.toolrack, Material.rock);
    GameRegistry.registerBlock(toolrack, tinker.armory.content.ToolrackItem.class, "ToolRack");
    GameRegistry.registerTileEntity(tinker.armory.content.ShieldrackLogic.class, "Display");
    shelf = new Shelf(PHArmory.shieldrack, Material.rock);
    GameRegistry.registerBlock(shelf, tinker.armory.content.ToolrackItem.class, "Shelf");
    GameRegistry.registerTileEntity(tinker.armory.content.ToolrackLogic.class, "aShelf");
    /*armorStand = new ArmorStand(1501, Material.rock);
    GameRegistry.registerBlock(armorStand, mDiyo.inficraft.armory.ArmorStandItem.class);
    GameRegistry.registerTileEntity(mDiyo.inficraft.armory.ArmorStandLogic.class, "InfiArmorStand");*/

    armorStandItem = new ArmorStandItem(PHArmory.armorItem).setItemName("armorstand");
    LanguageRegistry.instance().addName(armorStandItem, "Armor Stand");

    EntityRegistry.registerModEntity(
        tinker.armory.content.ArmorStandEntity.class, "Armor Stand", 0, this, 32, 5, true);
    NetworkRegistry.instance().registerGuiHandler(instance, new ArmoryGuiHandler());

    GameRegistry.addRecipe(
        new ItemStack(Armory.instance.armorStandItem, 1, 0),
        " c ",
        "csc",
        " b ",
        's',
        Item.stick,
        'c',
        Block.cobblestone,
        'b',
        Block.stoneSingleSlab);
  }
 @EventHandler
 public void preInit(FMLPreInitializationEvent e) {
   MinecraftForge.EVENT_BUS.register(new EventHookContainer());
   NetworkRegistry.instance().registerGuiHandler(this, new GuiHandler());
   ConfigHandler.init(e.getSuggestedConfigurationFile());
   if (ModInfo.updateInfo) UpdateChecker.init();
 }
 @EventHandler
 public void load(FMLInitializationEvent event) {
   // Register events
   NetworkRegistry.instance().registerGuiHandler(instance, proxy);
   LanguageRegistry.instance().addStringLocalization("itemGroup.Particular", "Particular");
   GameRegistry.registerWorldGenerator(eventmanager);
 }
  @Init
  public void init(FMLInitializationEvent event) {
    try {
      Class mystcraftApi = Class.forName("xcompwiz.mystcraft.api.APICallHandler");
      Class ageSymbol = Class.forName("xcompwiz.mystcraft.api.symbol.AgeSymbol");
      Class oreSymbol = Class.forName("shadow.mods.metallurgy.mystcraft.OreSymbol");
      Constructor constructor = oreSymbol.getConstructor(new Class[] {MetalSet.class});
      Method registerSymbol = mystcraftApi.getMethod("registerSymbol", new Class[] {ageSymbol});
      registerSymbol.invoke(mystcraftApi, constructor.newInstance(ores));
    } catch (Exception e) {
    }

    GameRegistry.registerBlock(PreciousChest, FC_ChestItemBlock.class);
    GameRegistry.registerTileEntity(FC_TileEntityChest.class, "PreciousChest");
    GameRegistry.registerBlock(Mint);
    GameRegistry.registerTileEntity(FM_TileEntityMint.class, "Mint");
    GameRegistry.registerBlock(MintStorage);
    GameRegistry.registerTileEntity(FM_TileEntityMintStorage.class, "MintStorage");

    if (ConfigPrecious.tradesEnabled)
      for (int i = 0; i < 5; i++)
        VillagerRegistry.instance().registerVillageTradeHandler(i, new PreciousTradeHandler());

    NetworkRegistry.instance().registerGuiHandler(instance, proxy);

    ((CreativeTabMetallurgy) creativeTab).setTabIconItemIndex(ores.Helmet[2].shiftedIndex);
    alloys.load();
    ores.load();

    proxy.addNames();
    proxy.registerTileEntitySpecialRenderer();
    proxy.registerRenderInformation();
    registerWithApi();
  }
  @Mod.EventHandler
  public void init(FMLInitializationEvent event) {
    MinecraftForge.EVENT_BUS.register(instance);
    MinecraftForge.EVENT_BUS.register(proxy);
    NetworkRegistry.instance().registerGuiHandler(instance, new ExplorationGuiHandler());

    proxy.init();
  }
Exemple #7
0
  @EventHandler
  public void load(FMLInitializationEvent event) {
    LanguageRegistry.instance().addStringLocalization("itemGroup.Pistronics2", "Pistronics 2");
    PacketData.init();
    proxy.registerTileEntities();
    NetworkRegistry.instance().registerGuiHandler(this, new GuiHandler());

    MinecraftForge.EVENT_BUS.register(arrowEventHandler);
  }
  @EventHandler
  public void init(FMLInitializationEvent event) {
    proxy.setupConfiguration();
    proxy.registerBlocks();
    proxy.registerTileEntities();
    proxy.registerItems();
    proxy.registerRenderers();

    NetworkRegistry.instance().registerGuiHandler(this, new GuiHandler());
    TickRegistry.registerTickHandler(new GoggleTickHandler(), Side.CLIENT);
  }
  @Init
  public void init(FMLInitializationEvent event) {
    /*
     * Register blocks to forge
     */
    LanguageRegistry.addName(blockDetector, "Detector");
    MinecraftForge.setBlockHarvestLevel(blockDetector, "pickaxe", 3);
    GameRegistry.registerBlock(blockDetector, "Detector");
    GameRegistry.registerTileEntity(TileDetector.class, "containerDetector");

    NetworkRegistry.instance().registerGuiHandler(this, new GuiHandler());
  }
  @SuppressWarnings("unchecked")
  @Init
  public void load(FMLInitializationEvent event) {

    // Register the GUI Handler
    NetworkRegistry.instance().registerGuiHandler(instance, proxy);

    // Register the PlayerDestroyItem Handler
    MinecraftForge.EVENT_BUS.register(new PlayerDestroyItemHandler());

    // Register the Item Pickup Handler
    MinecraftForge.EVENT_BUS.register(new ItemEventHandler());

    // Register the EntityLiving Handler
    MinecraftForge.EVENT_BUS.register(new EntityLivingHandler());

    MinecraftForge.EVENT_BUS.register(new ActionRequestHandler());

    MinecraftForge.EVENT_BUS.register(new WorldTransmutationHandler());

    GameRegistry.registerCraftingHandler(new CraftingHandler());

    // Register the DrawBlockHighlight Handler
    proxy.registerDrawBlockHighlightHandler();

    // Initialize mod tile entities
    proxy.registerTileEntities();

    // Initialize custom rendering and pre-load textures (Client only)
    proxy.initRenderingAndTextures();

    // Add in the ability to dye Alchemical Bags
    CraftingManager.getInstance().getRecipeList().add(new RecipesAlchemicalBagDyes());

    // Register the Fuel Handler
    GameRegistry.registerFuelHandler(new FuelHandler());

    // Quick test to see that sending an encoded recipe to be added to the recipe registry works
    FMLInterModComms.sendMessage(
        Reference.MOD_ID,
        InterModComms.ADD_RECIPE,
        NBTHelper.encodeRecipeAsNBT(
            Item.bucketWater, Arrays.asList(Item.bucketEmpty, Block.waterStill)));
    FMLInterModComms.sendMessage(
        Reference.MOD_ID,
        InterModComms.ADD_RECIPE,
        NBTHelper.encodeRecipeAsNBT(
            Item.bucketLava, Arrays.asList(Item.bucketEmpty, Block.lavaStill)));
  }
Exemple #11
0
  @PreInit
  public void preInit(FMLPreInitializationEvent event) {
    WCConfig.preInit(event);
    WCMCMod.preInit(event);
    WCBlockIDs.init();
    WCItemIDs.init();
    WCRecipes.init();
    WCAchievements.init();

    MinecraftForge.EVENT_BUS.register(new EventSounds());
    MinecraftForge.EVENT_BUS.register(new EventHookHandler());
    NetworkRegistry.instance().registerGuiHandler(this, guiHandler);
    GameRegistry.registerPickupHandler(itemHandler);
    DimensionManager.registerProviderType(DIM, WorldProviderWarp.class, true);
    DimensionManager.registerDimension(DIM, DIM);
  }
  @EventHandler
  public void preInit(FMLPreInitializationEvent evt) {
    ResonantInduction.LOGGER.setParent(FMLLog.getLogger());
    NetworkRegistry.instance().registerGuiHandler(this, proxy);
    Modstats.instance().getReporter().registerMod(this);
    Settings.CONFIGURATION.load();
    // Register Forge Events
    MinecraftForge.EVENT_BUS.register(ResourceGenerator.INSTANCE);
    MinecraftForge.EVENT_BUS.register(new TextureHookHandler());

    blockMachinePart =
        contentRegistry.createBlock(BlockMachineMaterial.class, ItemBlockMetadata.class);

    /** Melting dusts */
    blockDust =
        contentRegistry
            .createBlock("dust", BlockDust.class, null, TileDust.class)
            .setCreativeTab(null);
    blockRefinedDust =
        contentRegistry
            .createBlock("refinedDust", BlockDust.class, null, TileDust.class)
            .setCreativeTab(null);

    // Items
    itemRubble = new ItemOreResource(Settings.getNextItemID("oreRubble"), "oreRubble");
    itemDust = new ItemOreResource(Settings.getNextItemID("oreDust"), "oreDust");
    itemRefinedDust =
        new ItemOreResource(Settings.getNextItemID("oreRefinedDust"), "oreRefinedDust");
    itemBucketMixture =
        new ItemOreResourceBucket(Settings.getNextItemID("bucketMixture"), "bucketMixture", false);
    itemBucketMolten =
        new ItemOreResourceBucket(Settings.getNextItemID("bucketMolten"), "bucketMolten", true);
    itemBiomass = contentRegistry.createItem(ItemBiomass.class);

    GameRegistry.registerItem(itemRubble, itemRubble.getUnlocalizedName());
    GameRegistry.registerItem(itemDust, itemDust.getUnlocalizedName());
    GameRegistry.registerItem(itemRefinedDust, itemRefinedDust.getUnlocalizedName());
    GameRegistry.registerItem(itemBucketMixture, itemBucketMixture.getUnlocalizedName());
    GameRegistry.registerItem(itemBucketMolten, itemBucketMolten.getUnlocalizedName());

    // Already registered with ContentRegistry
    // GameRegistry.registerTileEntity(TileMaterial.class, "ri_material");
    GameRegistry.registerTileEntity(TileFluidMixture.class, "ri_fluid_mixture");

    proxy.preInit();
    TabRI.ITEMSTACK = new ItemStack(blockMachinePart);
  }
  @Init
  public void load(FMLInitializationEvent event) {
    // This is the place where the mod starts loading

    // Set the directory
    try {
      Field minecraftDir = Loader.class.getDeclaredField("minecraftDir");
      minecraftDir.setAccessible(true);
      terrainControlDirectory =
          new File((File) minecraftDir.get(null), "mods" + File.separator + "TerrainControl");
    } catch (Throwable e) {
      terrainControlDirectory = new File("mods" + File.separator + "TerrainControl");
      System.out.println(
          "Could not reflect the Minecraft directory, save location may be unpredicatble.");
      e.printStackTrace();
    }

    // Start TerrainControl engine
    TerrainControl.supportedBlockIds = 4095;
    TerrainControl.startEngine(this);

    // Register localization
    LanguageRegistry.instance().addStringLocalization("generator.TerrainControl", "TerrainControl");

    // Register world type
    worldType = new TCWorldType(this, "TerrainControl");

    // Register listening channel for listening to received configs.
    if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
      NetworkRegistry.instance()
          .registerChannel(new PacketHandler(this), TCDefaultValues.ChannelName.stringValue());
    }

    // Register player tracker, for sending configs.
    GameRegistry.registerPlayerTracker(new PlayerTracker(this));

    // Register sapling tracker, for custom tree growth.
    SaplingListener saplingListener = new SaplingListener();
    MinecraftForge.TERRAIN_GEN_BUS.register(saplingListener);
    MinecraftForge.EVENT_BUS.register(saplingListener);

    // Register to our own events, so that they can be fired again as Forge
    // events.
    // TODO: make this optional for people who haven't installed other
    // terrain mods, and don't want to lose performance.
    TerrainControl.registerEventHandler(new EventManager(), EventPriority.CANCELABLE);
  }
Exemple #14
0
 // @Mod.PostInit
 public void postInit(FMLPostInitializationEvent e) {
   registerBlocks();
   registerItems();
   registerOres();
   registerRecipes();
   registerTileEntities();
   registerRandomItems();
   registerWorldGenerators();
   registerContainers();
   registerEntities();
   registerVillagers();
   registerOther();
   if (client != null) client.postInit(e);
   if (proxy == null) proxy = this;
   NetworkRegistry.instance().registerGuiHandler(this, proxy);
   saveConfig();
 }
  @Init
  public void load(FMLInitializationEvent event) {
    proxy.Init();

    InitEntities.Init();

    InitBlocks.Init();

    InitItems.Init();

    NetworkRegistry.instance().registerGuiHandler(instance, proxy);

    TickRegistry.registerTickHandler(new CommonTickHandler(), Side.SERVER);

    TickRegistry.registerTickHandler(new ClientTickHandler(), Side.CLIENT);

    MinecraftForge.EVENT_BUS.register(new EntityLivingHandler());
  }
  @Init
  public void init(FMLInitializationEvent event) {
    // Set up the GUI handler
    NetworkRegistry.instance().registerGuiHandler(this, new GeneratorsGuiHandler());

    // Load the proxy
    proxy.loadConfiguration();
    proxy.registerSpecialTileEntities();
    proxy.registerRenderInformation();

    // Load this module
    addBlocks();
    addItems();
    addNames();
    addRecipes();
    addEntities();

    // Finalization
    Mekanism.logger.info("[MekanismGenerators] Loaded module.");
  }
  @EventHandler
  public void load(FMLInitializationEvent evt) {

    Localization.addLocalization("/lang/abo/", "en_US");

    // fix problem with autarchic gate initialization sequence
    ABORecipe recipe = new ABORecipe();

    recipe.itemID = pipeFluidsValve.itemID;
    recipe.isShapeless = true;
    recipe.result = new ItemStack(pipeFluidsValve, 1);
    recipe.input =
        new Object[] {BuildCraftTransport.pipeFluidsWood, BuildCraftTransport.pipeGateAutarchic};

    aboRecipes.add(recipe);

    loadRecipes();

    NetworkRegistry.instance().registerGuiHandler(instance, new ABOGuiHandler());
  }
  @Init
  public void load(FMLInitializationEvent evt) {
    // Register connection handler
    // MinecraftForge.registerConnectionHandler(new ConnectionHandler());

    // Register gui handler
    // MinecraftForge.setGuiHandler(mod_BuildCraftTransport.instance, new GuiHandler());

    TransportProxy.proxy.registerTileEntities();

    // dockingStationBlock = new
    // BlockDockingStation(Integer.parseInt(dockingStationId.value));
    // ModLoader.registerBlock(dockingStationBlock);
    // CoreProxy.addName(dockingStationBlock.setBlockName("dockingStation"),
    // "Docking Station");

    // ModLoader.RegisterTileEntity(TileDockingStation.class,
    // "net.minecraft.src.buildcraft.TileDockingStation");

    for (int j = 0; j < 6; ++j) {
      diamondTextures[j] = 1 * 16 + 6 + j;
    }

    new BptBlockPipe(genericPipeBlock.blockID);

    BuildCraftCore.itemBptProps[pipeItemsWood.itemID] = new BptItemPipeWooden();
    BuildCraftCore.itemBptProps[pipeLiquidsWood.itemID] = new BptItemPipeWooden();
    BuildCraftCore.itemBptProps[pipeItemsIron.itemID] = new BptItemPipeIron();
    BuildCraftCore.itemBptProps[pipeLiquidsIron.itemID] = new BptItemPipeIron();
    BuildCraftCore.itemBptProps[pipeItemsDiamond.itemID] = new BptItemPipeDiamond();
    BuildCraftCore.itemBptProps[pipeItemsEmerald.itemID] = new BptItemPipeEmerald();

    ActionManager.registerTriggerProvider(new PipeTriggerProvider());

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

    TransportProxy.proxy.registerRenderers();
    NetworkRegistry.instance().registerGuiHandler(instance, new GuiHandler());
  }
Exemple #19
0
  public void init() {
    // create block and register it
    OpenCCSensors.Blocks.sensorBlock =
        new BlockSensor(OpenCCSensors.Config.sensorBlockID, Material.cloth);
    GameRegistry.registerBlock(OpenCCSensors.Blocks.sensorBlock, "OCS");
    GameRegistry.registerTileEntity(TileEntitySensor.class, "sensor");
    OpenCCSensors.Blocks.sensorBlock.setHardness(0.5F);
    GameRegistry.addRecipe(
        new ItemStack(OpenCCSensors.Blocks.sensorBlock, 1, 0),
        "ooo",
        "ror",
        "sss",
        'o',
        new ItemStack(Block.obsidian),
        'r',
        new ItemStack(Item.redstone),
        's',
        new ItemStack(Block.stone));

    OpenCCSensors.Blocks.gaugeBlock =
        new BlockGauge(OpenCCSensors.Config.gaugeBlockID, Material.cloth);
    GameRegistry.registerBlock(OpenCCSensors.Blocks.gaugeBlock, "OCS.gauge");
    GameRegistry.registerTileEntity(TileEntityGauge.class, "gauge");
    OpenCCSensors.Blocks.gaugeBlock.setHardness(0.5F);

    // register turtle peripheral if applicable
    if (OpenCCSensors.Config.turtlePeripheralEnabled) {
      dan200.turtle.api.TurtleAPI.registerUpgrade(new TurtleUpgradeSensor());
    }

    // register GUI handler
    NetworkRegistry.instance().registerGuiHandler(OpenCCSensors.instance, new GuiHandler());

    // setup languages
    setupLanguages();

    setupLuaFiles();
  }
  @Subscribe
  public void init(FMLInitializationEvent ev) {
    FMLCommonHandler.instance().registerCrashCallable(new BukkitCrashCallable());
    bukkitLogger.info("Complete! Registering handlers...");
    NetworkRegistry.instance().registerConnectionHandler(new ConnectionHandler());
    if (Loader.isModLoaded("BlockBreak")) {
      try {
        MinecraftForge.EVENT_BUS.register(new BlockBreakEventHandler());
      } catch (Exception e) {
        bukkitLogger.log(Level.FINE, "BlockBreak is present, but not!", e);
      }
    }

    try {
      MinecraftForge.EVENT_BUS.register(new ForgeEventHandler());
    } catch (Throwable e) {
      FMLCommonHandler.instance()
          .getFMLLogger()
          .log(Level.SEVERE, "[Bukkit API]: FAILED to add event handers:", e);
      // e.printStackTrace();
    }
    bukkitLogger.info("Done!");
  }
Exemple #21
0
  @Init
  public void load(FMLInitializationEvent event) {
    NetworkRegistry.instance().registerGuiHandler(this, guiHandler);

    proxy.registerRenderers();

    registerBlocks();

    registerFuel();

    registerItems();

    registerRecipes();

    registerOres();

    registerTileEntities();

    proxy.registerTextureFX();

    registerEntities();

    GameRegistry.registerWorldGenerator(new WorldGenerator());
  }
  @Init
  public void load(FMLInitializationEvent event) {
    NetworkRegistry.instance().registerGuiHandler(this, new GuiHandler());
    LanguageRegistry.instance()
        .addStringLocalization("itemGroup.tabChemistryzation", "en_US", "Chemistryzation");

    BunsenBurner =
        new BlockBunsenBurner(501, Material.rock)
            .setUnlocalizedName("BunsenBurner")
            .setCreativeTab(tabChemistryzation);
    GameRegistry.registerBlock(BunsenBurner, modid + "BunsenBurner");
    LanguageRegistry.addName(BunsenBurner, "BunsenBurner");
    GameRegistry.registerTileEntity(TileEntityBunsenBurner.class, "ContainerBunsenBurner");

    GameRegistry.registerWorldGenerator(WorldGen);

    NaClBlock =
        new BlockNaClBlock(500, Material.rock)
            .setUnlocalizedName("NaClBlock")
            .setCreativeTab(tabChemistryzation);
    GameRegistry.registerBlock(NaClBlock, modid + "NaClBlock");
    LanguageRegistry.addName(NaClBlock, "Salt");

    CuFeS2 =
        new BlockCuFeS2(502, Material.rock)
            .setUnlocalizedName("CuFeS2")
            .setCreativeTab(tabChemistryzation);
    GameRegistry.registerBlock(CuFeS2, modid + "CuFeS2");
    LanguageRegistry.addName(CuFeS2, "CuFeS2");

    NaClItem =
        new ItemNaClItem(5000).setUnlocalizedName("NaClItem").setCreativeTab(tabChemistryzation);
    LanguageRegistry.addName(NaClItem, "NaCl");

    NaClInBucketSolid =
        new NaClInBucketSolid(5001)
            .setUnlocalizedName("NaClInBucketSolid")
            .setCreativeTab(tabChemistryzation);
    LanguageRegistry.addName(NaClInBucketSolid, "NaCl");

    NaClInBucketMelted =
        new NaClInBucketMelted(5002)
            .setUnlocalizedName("NaClInBucketMelted")
            .setCreativeTab(tabChemistryzation);
    LanguageRegistry.addName(NaClInBucketMelted, "NaCl");

    TestTube = new TestTube(5003).setUnlocalizedName("TestTube").setCreativeTab(tabChemistryzation);
    LanguageRegistry.addName(TestTube, "Test Tube");

    NaClInTestTubeSolid =
        new NaClInTestTubeSolid(5004)
            .setUnlocalizedName("NaClInTestTubeSolid")
            .setCreativeTab(tabChemistryzation);
    LanguageRegistry.addName(NaClInTestTubeSolid, "NaCl");

    GameRegistry.addRecipe(
        new ItemStack(Chemistryzation.TestTube, 8),
        "XYX",
        "X X",
        " X ",
        Character.valueOf('X'),
        new ItemStack(Block.glass),
        Character.valueOf('Y'),
        Item.slimeBall);

    ItemStack NaClItemStack = new ItemStack(Chemistryzation.NaClItem);
    GameRegistry.addShapelessRecipe(
        new ItemStack(NaClInBucketSolid),
        new Object[] {
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          new ItemStack(Item.bucketEmpty)
        });
    GameRegistry.addShapelessRecipe(
        new ItemStack(NaClInTestTubeSolid),
        new Object[] {
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          NaClItemStack,
          new ItemStack(Chemistryzation.TestTube)
        });
    FurnaceRecipes.smelting()
        .addSmelting(
            Chemistryzation.NaClInBucketSolid.itemID,
            0,
            new ItemStack(Chemistryzation.NaClInBucketMelted),
            0.1F);
  }
 private void addGUIs() {
   NetworkRegistry.instance().registerGuiHandler(this, new MFGuiHandler());
 }
 @Init
 public void init(FMLInitializationEvent event) {
   NetworkRegistry.instance().registerGuiHandler(instance, new GuiHandler());
 }
 @Override
 public void load(FMLInitializationEvent e) {
   Chat chat = new Chat();
   MinecraftForge.EVENT_BUS.register(chat);
   NetworkRegistry.instance().registerChatListener(chat);
 }
  @Init
  public void load(FMLInitializationEvent evt) {
    // Create filler registry
    FillerManager.registry = new FillerRegistry();

    // Register gui handler
    NetworkRegistry.instance().registerGuiHandler(instance, new GuiHandler());

    // Register save handler
    MinecraftForge.EVENT_BUS.register(new EventHandlerBuilders());

    new BptBlock(0); // default bpt block

    new BptBlockIgnore(Block.snow.blockID);
    new BptBlockIgnore(Block.tallGrass.blockID);
    new BptBlockIgnore(Block.ice.blockID);
    new BptBlockIgnore(Block.pistonExtension.blockID);

    new BptBlockDirt(Block.dirt.blockID);
    new BptBlockDirt(Block.grass.blockID);
    new BptBlockDirt(Block.tilledField.blockID);

    new BptBlockDelegate(Block.torchRedstoneIdle.blockID, Block.torchRedstoneActive.blockID);
    new BptBlockDelegate(Block.furnaceBurning.blockID, Block.furnaceIdle.blockID);
    new BptBlockDelegate(Block.pistonMoving.blockID, Block.pistonBase.blockID);

    new BptBlockWallSide(Block.torchWood.blockID);
    new BptBlockWallSide(Block.torchRedstoneActive.blockID);

    new BptBlockRotateMeta(Block.ladder.blockID, new int[] {2, 5, 3, 4}, true);
    new BptBlockRotateMeta(Block.fenceGate.blockID, new int[] {0, 1, 2, 3}, true);

    new BptBlockRotateInventory(Block.furnaceIdle.blockID, new int[] {2, 5, 3, 4}, true);
    new BptBlockRotateInventory(Block.chest.blockID, new int[] {2, 5, 3, 4}, true);
    new BptBlockRotateInventory(Block.lockedChest.blockID, new int[] {2, 5, 3, 4}, true);
    new BptBlockRotateInventory(Block.dispenser.blockID, new int[] {2, 5, 3, 4}, true);

    new BptBlockInventory(Block.brewingStand.blockID);

    new BptBlockRotateMeta(Block.vine.blockID, new int[] {1, 4, 8, 2}, false);
    new BptBlockRotateMeta(Block.trapdoor.blockID, new int[] {0, 1, 2, 3}, false);

    new BptBlockLever(Block.woodenButton.blockID);
    new BptBlockLever(Block.stoneButton.blockID);
    new BptBlockLever(Block.lever.blockID);

    new BptBlockCustomStack(Block.stone.blockID, new ItemStack(Block.stone));
    new BptBlockCustomStack(Block.redstoneWire.blockID, new ItemStack(Item.redstone));
    // FIXME: Not sure what this has become
    // new BptBlockCustomStack(Block.stairDouble.blockID, new ItemStack(Block.stairSingle, 2));
    new BptBlockCustomStack(Block.cake.blockID, new ItemStack(Item.cake));
    new BptBlockCustomStack(Block.crops.blockID, new ItemStack(Item.seeds));
    new BptBlockCustomStack(Block.pumpkinStem.blockID, new ItemStack(Item.pumpkinSeeds));
    new BptBlockCustomStack(Block.melonStem.blockID, new ItemStack(Item.melonSeeds));
    new BptBlockCustomStack(Block.glowStone.blockID, new ItemStack(Block.glowStone));

    new BptBlockRedstoneRepeater(Block.redstoneRepeaterActive.blockID);
    new BptBlockRedstoneRepeater(Block.redstoneRepeaterIdle.blockID);

    new BptBlockLiquid(Block.waterStill.blockID, new ItemStack(Item.bucketWater));
    new BptBlockLiquid(Block.waterMoving.blockID, new ItemStack(Item.bucketWater));
    new BptBlockLiquid(Block.lavaStill.blockID, new ItemStack(Item.bucketLava));
    new BptBlockLiquid(Block.lavaMoving.blockID, new ItemStack(Item.bucketLava));

    new BptBlockIgnoreMeta(Block.rail.blockID);
    new BptBlockIgnoreMeta(Block.railPowered.blockID);
    new BptBlockIgnoreMeta(Block.railDetector.blockID);
    new BptBlockIgnoreMeta(Block.thinGlass.blockID);

    new BptBlockPiston(Block.pistonBase.blockID);
    new BptBlockPiston(Block.pistonStickyBase.blockID);

    new BptBlockPumpkin(Block.pumpkinLantern.blockID);

    new BptBlockStairs(Block.stairsCobblestone.blockID);
    new BptBlockStairs(Block.stairsWoodOak.blockID);
    new BptBlockStairs(Block.stairsNetherBrick.blockID);
    new BptBlockStairs(Block.stairsBrick.blockID);
    new BptBlockStairs(Block.stairsStoneBrick.blockID);

    new BptBlockDoor(Block.doorWood.blockID, new ItemStack(Item.doorWood));
    new BptBlockDoor(Block.doorIron.blockID, new ItemStack(Item.doorIron));

    new BptBlockBed(Block.bed.blockID);

    new BptBlockSign(Block.signWall.blockID, true);
    new BptBlockSign(Block.signPost.blockID, false);

    // BUILDCRAFT BLOCKS

    new BptBlockRotateInventory(architectBlock.blockID, new int[] {2, 5, 3, 4}, true);
    new BptBlockRotateInventory(builderBlock.blockID, new int[] {2, 5, 3, 4}, true);

    new BptBlockInventory(libraryBlock.blockID);

    new BptBlockWallSide(markerBlock.blockID);
    new BptBlockWallSide(pathMarkerBlock.blockID);
    new BptBlockFiller(fillerBlock.blockID);

    if (BuildCraftCore.loadDefaultRecipes) {
      loadRecipes();
    }
  }
Exemple #27
0
  @PreInit
  public void postInit(FMLPreInitializationEvent event) {

    // Registers(Kayitlar)
    MinecraftForge.EVENT_BUS.register(new SoundHandler());

    RenderingRegistry.registerEntityRenderingHandler(
        ghost.class, new render(new ghostmodel(), 0.3F));
    RenderingRegistry.registerEntityRenderingHandler(
        Badghost.class, new Badghostrender(new ghostmodel(), 0.3F));
    ClientRegistry.bindTileEntitySpecialRenderer(
        TileEntityCopperWire.class, new RenderCopperWire());
    ClientRegistry.bindTileEntitySpecialRenderer(
        TileEntitySolarGenerator.class, new RenderSolarPanel());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBatteryBox.class, new RenderBattery());
    ClientRegistry.bindTileEntitySpecialRenderer(
        TileEntityCoalGenerator.class, new RenderGenerator());
    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityEF.class, new RenderEFurnace());

    if (MECLiquid.blockID + 1 != MECLiquidStill.blockID) {
      throw new RuntimeException("Liquid Still id must be Liquid Moving id + 1");
    }
    dirtBucket = (MECBucketHandler) new MECBucketHandler();
    MinecraftForge.EVENT_BUS.register(new MECBucketHandler());
    ModLoader.registerEntityID(Badghost.class, "Banion", 8, x, y);
    ModLoader.registerEntityID(ghost.class, "Mip", 7, x, y);
    ModLoader.getUniqueEntityId();
    ModLoader.addSpawn(ghost.class, 10, 4, 7, EnumCreatureType.ambient, MarbleBiome);
    ModLoader.addSpawn(Badghost.class, 14, 4, 7, EnumCreatureType.ambient, MarbleBiome);

    LanguageRegistry.instance().addStringLocalization("entity.Mip.name", "en_US", "Mip");
    LanguageRegistry.instance().addStringLocalization("entity.Banion.name", "en_US", "Banion");
    IronPlate =
        new IronPlate(ItemID + 5)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("plateIron");
    GoldPlate =
        new IronPlate(ItemID + 6)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("plateGold");
    CopperPlate =
        new IronPlate(ItemID + 7)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("plateCopper");
    SteelPlate =
        new IronPlate(ItemID + 8)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("plateSteel");
    CopperIngot =
        new ItemMEC(ItemID + 9)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("ingotCopper");
    SteelIngot =
        new ItemMEC(ItemID + 10)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("ingotSteel");
    Heart =
        new Heart(ItemID, 10, 12, true)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("heart");
    GHeart =
        new GHeart(ItemID + 1, -10, 12, true)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("gheart");
    MECBucket =
        new MECBucket(ItemID + 2)
            .setCreativeTab(MEC)
            .setUnlocalizedName("mbucket")
            .setContainerItem(Item.bucketEmpty);
    MECWrench =
        new MECWrench(ItemID + 17)
            .setMaxStackSize(64)
            .setCreativeTab(MEC)
            .setUnlocalizedName("wrench");
    Batery = new ItemBattery("battery", ItemID + 3).setMaxStackSize(1);
    IBatery = new ItemInfiniteBattery("infinitebattery", ItemID + 4).setMaxDamage(1);
    CPHelmet =
        (ItemArmor)
            (new ItemArmorCP(ItemID + 11, CPA, proxy.addArmor(CPA.name()), 0))
                .setUnlocalizedName("cp_helmet")
                .func_111206_d("cp_helmet");
    CPChestPlate =
        (ItemArmor)
            (new ItemArmorCP(ItemID + 12, CPA, proxy.addArmor(CPA.name()), 1))
                .setUnlocalizedName("cp_chestplate")
                .func_111206_d("cp_chestplate");
    // CPChestPlateWW = (ItemArmor)(new ItemArmorCP(ItemID + 15, CPA, proxy.addArmor(CPA.name()),
    // 1)).setUnlocalizedName("cp_chestplate").func_111206_d("cp_chestplate");
    CPLeggings =
        (ItemArmor)
            (new ItemArmorCP(ItemID + 13, CPA, proxy.addArmor(CPA.name()), 2))
                .setUnlocalizedName("cp_leggings")
                .func_111206_d("cp_leggings");
    CPBoots =
        (ItemArmor)
            (new ItemArmorCP(ItemID + 14, CPA, proxy.addArmor(CPA.name()), 3))
                .setUnlocalizedName("cp_boots")
                .func_111206_d("cp_boots");
    CPSword = new ItemSwordCP(ItemID + 16, CP).setUnlocalizedName("cp_sword");
    CSoulPart = new ItemMEC(ItemID + 18).setUnlocalizedName("csp");
    PSoulPart = new ItemMEC(ItemID + 19).setUnlocalizedName("psp");
    CWSoulPart = new ItemMEC(ItemID + 20).setUnlocalizedName("cwsp");
    ESoulPart = new ItemMEC(ItemID + 21).setUnlocalizedName("esp");
    ZSoulPart = new ItemMEC(ItemID + 22).setUnlocalizedName("zsp");
    CRSoulPart = new ItemMEC(ItemID + 23).setUnlocalizedName("crsp");
    SSoulPart = new ItemMEC(ItemID + 24).setUnlocalizedName("ssp");
    HSoulPart = new ItemMEC(ItemID + 25).setUnlocalizedName("hsp");
    GameRegistry.registerItem(CSoulPart, "Chicken Soul Part");
    GameRegistry.registerItem(PSoulPart, "Pig Soul Part");
    GameRegistry.registerItem(CWSoulPart, "Cow Soul Part");
    GameRegistry.registerItem(ESoulPart, "Enderman Soul Part");
    GameRegistry.registerItem(ZSoulPart, "Zombie Soul Part");
    GameRegistry.registerItem(CRSoulPart, "Creeper Soul Part");
    GameRegistry.registerItem(SSoulPart, "Spider Soul Part");
    GameRegistry.registerItem(HSoulPart, "Horse Soul Part");
    GameRegistry.registerItem(CPSword, "Corruption Sword");
    GameRegistry.registerItem(CPHelmet, "Corruption Helmet");
    GameRegistry.registerItem(CPChestPlate, "Corruption Chestplate");
    GameRegistry.registerItem(CPLeggings, "Corruption Leggings");
    GameRegistry.registerItem(CPBoots, "Corruption Boots");
    GameRegistry.registerItem(IronPlate, "Iron Plate");
    GameRegistry.registerItem(GoldPlate, "Gold Plate");
    GameRegistry.registerItem(CopperPlate, "Copper Plate");
    GameRegistry.registerItem(SteelPlate, "Steel Plate");
    GameRegistry.registerItem(CopperIngot, "Copper Ingot");
    GameRegistry.registerItem(SteelIngot, "Steel Ingot");
    GameRegistry.registerItem(Heart, "Innocent Heart");
    GameRegistry.registerItem(GHeart, "Guilty Heart");
    GameRegistry.registerItem(MECWrench, "MEC Wrench");
    GameRegistry.registerItem(MECBucket, "Pressure Machine Fuel");
    GameRegistry.registerItem(Batery, "Battery");
    GameRegistry.registerItem(IBatery, "Infinite Battery");
    GameRegistry.registerPickupHandler(new PickupHandler());
    GameRegistry.registerCraftingHandler(new CraftingHandler());
    LanguageRegistry.addName(CSoulPart, "\u00A7c" + "Chicken Soul Part");
    LanguageRegistry.addName(PSoulPart, "\u00A7c" + "Pig Soul Part");
    LanguageRegistry.addName(CWSoulPart, "\u00A7c" + "Cow Soul Part");
    LanguageRegistry.addName(ESoulPart, "\u00A7c" + "Enderman Soul Part");
    LanguageRegistry.addName(ZSoulPart, "\u00A7c" + "Zombie Soul Part");
    LanguageRegistry.addName(CRSoulPart, "\u00A7c" + "Creeper Soul Part");
    LanguageRegistry.addName(SSoulPart, "\u00A7c" + "Spider Soul Part");
    LanguageRegistry.addName(HSoulPart, "\u00A7c" + "Horse Soul Part");
    LanguageRegistry.addName(CPSword, "\u00A7e" + "Corruption Sword");
    LanguageRegistry.addName(CPHelmet, "\u00A7e" + "Corruption Helmet");
    LanguageRegistry.addName(CPChestPlate, "\u00A7e" + "Corruption Chestplate");
    LanguageRegistry.addName(CPLeggings, "\u00A7e" + "Corruption Leggings");
    LanguageRegistry.addName(CPBoots, "\u00A7e" + "Corruption Boots");
    LanguageRegistry.addName(IronPlate, "" + "Iron Plate");
    LanguageRegistry.addName(GoldPlate, "Gold Plate");
    LanguageRegistry.addName(CopperPlate, "Copper Plate");
    LanguageRegistry.addName(SteelPlate, "Steel Plate");
    LanguageRegistry.addName(CopperIngot, "Copper Ingot");
    LanguageRegistry.addName(SteelIngot, "Steel Ingot");
    LanguageRegistry.addName(Batery, "Battery");
    LanguageRegistry.addName(IBatery, "Infinite Battery");
    LanguageRegistry.instance().addStringLocalization("itemGroup.MEC", "en_US", "ME-Craft");
    LanguageRegistry.addName(Heart, "Innocent Heart");
    LanguageRegistry.addName(GHeart, "Guilty Heart");
    LanguageRegistry.addName(MECBucket, "Pressure Machine Fuel");
    LanguageRegistry.addName(MECWrench, "MEC Wrench");
    GameRegistry.registerBlock(blocksolar, "Solar Generator");
    GameRegistry.registerBlock(blockbat, "Battery Box");
    GameRegistry.registerBlock(CPSnad, "Corruption Sand");
    GameRegistry.registerBlock(CopperOre, "Copper Ore");
    GameRegistry.registerBlock(Mermer, "Marble");
    GameRegistry.registerBlock(KirikMermer, "Cobblemurble");
    GameRegistry.registerBlock(AMermer, "Light Blue Marble");
    GameRegistry.registerBlock(BMermer, "Light Gray Marble");
    GameRegistry.registerBlock(CMermer, "Lime Marble");
    GameRegistry.registerBlock(DMermer, "Magenta Marble");
    GameRegistry.registerBlock(EMermer, "Gray Marble");
    GameRegistry.registerBlock(FMermer, "Brown Marble");
    GameRegistry.registerBlock(GMermer, "Red Marble");
    GameRegistry.registerBlock(HMermer, "Blue Marble");
    GameRegistry.registerBlock(SMermer, "Fake Marble");
    GameRegistry.registerBlock(IMermer, "Purple Marble");
    GameRegistry.registerBlock(JMermer, "Pink Marble");
    GameRegistry.registerBlock(KMermer, "Yellow Marble");
    GameRegistry.registerBlock(LMermer, "Black Marble");
    GameRegistry.registerBlock(MMermer, "Cyan Marble");
    GameRegistry.registerBlock(NMermer, "Orange Marble");
    GameRegistry.registerBlock(OMermer, "Green Marble");
    GameRegistry.registerBlock(AMermerB, "Light Blue Marble Brick");
    GameRegistry.registerBlock(BMermerB, "Light Gray Marble Brick");
    GameRegistry.registerBlock(CMermerB, "Lime Marble Brick");
    GameRegistry.registerBlock(DMermerB, "Magenta Marble Brick");
    GameRegistry.registerBlock(EMermerB, "Gray Marble Brick");
    GameRegistry.registerBlock(FMermerB, "Brown Marble Brick");
    GameRegistry.registerBlock(GMermerB, "Red Marble Brick");
    GameRegistry.registerBlock(HMermerB, "Blue Marble Brick");
    GameRegistry.registerBlock(IMermerB, "Purple Marble Brick");
    GameRegistry.registerBlock(JMermerB, "Pink Marble Brick");
    GameRegistry.registerBlock(KMermerB, "Yellow Marble Brick");
    GameRegistry.registerBlock(LMermerB, "Black Marble Brick");
    GameRegistry.registerBlock(MMermerB, "Cyan Marble Brick");
    GameRegistry.registerBlock(NMermerB, "Orange Marble Brick");
    GameRegistry.registerBlock(OMermerB, "Green Marble Brick");
    GameRegistry.registerBlock(MermerB, "Marble Brick");
    GameRegistry.registerBlock(Deneme, "Pressure Machine");
    GameRegistry.registerBlock(DenemeB, "Pressure Machine Working");
    ClientRegistry.bindTileEntitySpecialRenderer(
        TileEntityCopperWire.class, new RenderCopperWire());
    ClientRegistry.bindTileEntitySpecialRenderer(
        TileEntitySolarGenerator.class, new RenderSolarPanel());

    GameRegistry.registerTileEntity(TileEntityCopperWire.class, "Copper Cable");
    GameRegistry.registerBlock(CopperCable, ItemBlockCopperWire.class, "");
    proxy.registerCopperWireTileEntity();
    proxy.registerSG();
    proxy.registerBB();
    GameRegistry.registerBlock(MECLiquid, "MECLiquid");
    GameRegistry.registerBlock(MECLiquidStill, "MECLiquidStill");
    GameRegistry.registerTileEntity(MECTileEntity.class, "MECTile");
    NetworkRegistry.instance().registerGuiHandler(this, guihandler);
    LanguageRegistry.addName(blockbat, "Battery Box");
    LanguageRegistry.addName(blocksolar, "Solar Generator");
    LanguageRegistry.addName(MECLiquid, "MECLiquid");
    LanguageRegistry.addName(MECLiquidStill, "MECLiquidStill");
    LanguageRegistry.addName(KirikMermer, "CobbleMurble");
    LanguageRegistry.addName(CPSnad, "Corruption Sand");
    LanguageRegistry.addName(CopperOre, "Copper Ore");
    LanguageRegistry.addName(Mermer, "Marble");
    LanguageRegistry.addName(Deneme, "Pressure Machine");
    LanguageRegistry.addName(DenemeB, "Pressure Machine");
    LanguageRegistry.addName(MermerB, "Marble Brick");
    LanguageRegistry.addName(SMermer, "Fake Marble");
    LanguageRegistry.addName(AMermer, "Light Blue Marble");
    LanguageRegistry.addName(BMermer, "Light Gray Marble");
    LanguageRegistry.addName(CMermer, "Lime Marble");
    LanguageRegistry.addName(DMermer, "Magenta Marble");
    LanguageRegistry.addName(EMermer, "Gray Marble");
    LanguageRegistry.addName(FMermer, "Brown Marble");
    LanguageRegistry.addName(GMermer, "Red Marble");
    LanguageRegistry.addName(HMermer, "Blue Marble");
    LanguageRegistry.addName(IMermer, "Purple Marble");
    LanguageRegistry.addName(JMermer, "Pink Marble");
    LanguageRegistry.addName(KMermer, "Yellow Marble");
    LanguageRegistry.addName(LMermer, "Black Marble");
    LanguageRegistry.addName(MMermer, "Cyan Marble");
    LanguageRegistry.addName(NMermer, "Orange Marble");
    LanguageRegistry.addName(OMermer, "Green Marble");
    LanguageRegistry.addName(AMermerB, "Light Blue Marble Brick");
    LanguageRegistry.addName(BMermerB, "Light Gray Marble Brick");
    LanguageRegistry.addName(CMermerB, "Lime Marble Brick");
    LanguageRegistry.addName(DMermerB, "Magenta Marble Brick");
    LanguageRegistry.addName(EMermerB, "Gray Marble Brick");
    LanguageRegistry.addName(FMermerB, "Brown Marble Brick");
    LanguageRegistry.addName(GMermerB, "Red Marble Brick");
    LanguageRegistry.addName(HMermerB, "Blue Marble Brick");
    LanguageRegistry.addName(IMermerB, "Purple Marble Brick");
    LanguageRegistry.addName(JMermerB, "Pink Marble Brick");
    LanguageRegistry.addName(KMermerB, "Yellow Marble Brick");
    LanguageRegistry.addName(LMermerB, "Black Marble Brick");
    LanguageRegistry.addName(MMermerB, "Cyan Marble Brick");
    LanguageRegistry.addName(NMermerB, "Orange Marble Brick");
    LanguageRegistry.addName(OMermerB, "Green Marble Brick");
    OreDictionary.registerOre("copperWire", new ItemStack(CopperCable, 1, 0));

    UniversalElectricity.isVoltageSensitive = true;
    UniversalElectricity.isNetworkActive = true;
    GameRegistry.registerTileEntity(TileEntityCoalGenerator.class, "Generator");
    GameRegistry.registerTileEntity(TileEntityElectricFurnace.class, "PM");
    GameRegistry.registerTileEntity(TileEntityBatteryBox.class, "BB");
    GameRegistry.registerTileEntity(TileEntityEF.class, "EF");
    GameRegistry.registerTileEntity(TileEntitySolarGenerator.class, "SG");
    GameRegistry.registerBlock(blockMachine, ItemBlockBasicMachine.class, "Temel Machine");
    OreDictionary.registerOre("generator", ((BlockBasicMachine) blockMachine).getCoalGenerator());
    OreDictionary.registerOre("PM", ((BlockBasicMachine) blockMachine).getElectricFurnace());
    OreDictionary.registerOre("EM", ((BlockBasicMachine) blockMachine).getAS());
    OreDictionary.registerOre("SG", new ItemStack(blocksolar, 1));
    LanguageRegistry.addName(blockMachine.getCoalGenerator(), "Generator");
    LanguageRegistry.addName(blockMachine.getElectricFurnace(), "Electric Pressure Machine");
    LanguageRegistry.addName(blockMachine.getAS(), "Electric Furnace");

    LanguageRegistry.addName(CopperCable, "Copper Cable");
    if (CopperCable != null) {
      UniversalElectricity.isNetworkActive = true;
    }
    this.addAchievementLocalizations();
    LanguageRegistry.instance().addStringLocalization("achievement.Marble", "Start the Mod");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Marble.desc", "You are starting the Mod");
    LanguageRegistry.instance().addStringLocalization("achievement.Marble2", "Get The Marble");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Marble2.desc", "You are Learning Something!");
    LanguageRegistry.instance().addStringLocalization("achievement.Copper", "Find Copper");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Copper.desc", "You found a new Ore");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Pressure", "Make a Pressure Machine");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Pressure.desc", "You can make awesome things!");
    LanguageRegistry.instance().addStringLocalization("achievement.Heart", "Friend Slayer");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.Heart.desc", "You killed a Friend Mip");
    LanguageRegistry.instance().addStringLocalization("achievement.GHeart", "Enemy Slayer");
    LanguageRegistry.instance()
        .addStringLocalization("achievement.GHeart.desc", "You killed a Enemy Banion");

    MinecraftForge.EVENT_BUS.register(new Sounds());
    ModLoader.addBiome(MarbleBiome);
    GameRegistry.registerWorldGenerator(worldGen);
    GameRegistry.registerWorldGenerator(worldGenCopper);
    GameRegistry.registerWorldGenerator(worldGenML);

    // GameRegistry.registerTileEntity(TileEntityRedstoneWireBlock.class,
    // "TileEntityRedstoneWireBlock");
    AchievementPage.registerAchievementPage(page1);

    GameRegistry.registerTileEntity(TileEntityHiveCore.class, "TileEntityRedstoneNetworkCore");

    // GameRegistry.registerTileEntity(TileEntityRedstoneWireBlock.class,
    // "TileEntityRedstoneWireBlock");

    // Recipes(Formuller):
    ModLoader.addShapelessRecipe(
        new ItemStack(SMermer, 2), Block.stone, new ItemStack(Item.dyePowder, 1, 15));
    ModLoader.addShapelessRecipe(
        new ItemStack(AMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 12));
    ModLoader.addShapelessRecipe(
        new ItemStack(BMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 7));
    ModLoader.addShapelessRecipe(
        new ItemStack(CMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 10));
    ModLoader.addShapelessRecipe(
        new ItemStack(DMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 13));
    ModLoader.addShapelessRecipe(
        new ItemStack(EMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 8));
    ModLoader.addShapelessRecipe(
        new ItemStack(FMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 3));
    ModLoader.addShapelessRecipe(
        new ItemStack(GMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 1));
    ModLoader.addShapelessRecipe(
        new ItemStack(HMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 4));
    ModLoader.addShapelessRecipe(
        new ItemStack(IMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 5));
    ModLoader.addShapelessRecipe(
        new ItemStack(JMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 9));
    ModLoader.addShapelessRecipe(
        new ItemStack(KMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 11));
    ModLoader.addShapelessRecipe(
        new ItemStack(LMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 0));
    ModLoader.addShapelessRecipe(
        new ItemStack(MMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 6));
    ModLoader.addShapelessRecipe(
        new ItemStack(NMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 14));
    ModLoader.addShapelessRecipe(
        new ItemStack(OMermer, 2), Mermer, new ItemStack(Item.dyePowder, 1, 2));
    ModLoader.addShapelessRecipe(
        new ItemStack(AMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 12));
    ModLoader.addShapelessRecipe(
        new ItemStack(BMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 7));
    ModLoader.addShapelessRecipe(
        new ItemStack(CMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 10));
    ModLoader.addShapelessRecipe(
        new ItemStack(DMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 13));
    ModLoader.addShapelessRecipe(
        new ItemStack(EMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 8));
    ModLoader.addShapelessRecipe(
        new ItemStack(FMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 3));
    ModLoader.addShapelessRecipe(
        new ItemStack(GMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 1));
    ModLoader.addShapelessRecipe(
        new ItemStack(HMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 4));
    ModLoader.addShapelessRecipe(
        new ItemStack(IMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 5));
    ModLoader.addShapelessRecipe(
        new ItemStack(JMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 9));
    ModLoader.addShapelessRecipe(
        new ItemStack(KMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 11));
    ModLoader.addShapelessRecipe(
        new ItemStack(LMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 0));
    ModLoader.addShapelessRecipe(
        new ItemStack(MMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 6));
    ModLoader.addShapelessRecipe(
        new ItemStack(NMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 14));
    ModLoader.addShapelessRecipe(
        new ItemStack(OMermer, 2), SMermer, new ItemStack(Item.dyePowder, 1, 2));
    ModLoader.addRecipe(new ItemStack(MermerB, 4), "xx", "xx", 'x', Mermer);
    ModLoader.addRecipe(new ItemStack(MermerB, 4), "xx", "xx", 'x', SMermer);
    ModLoader.addRecipe(new ItemStack(AMermerB, 4), "xx", "xx", 'x', AMermer);
    ModLoader.addRecipe(new ItemStack(BMermerB, 4), "xx", "xx", 'x', BMermer);
    ModLoader.addRecipe(new ItemStack(CMermerB, 4), "xx", "xx", 'x', CMermer);
    ModLoader.addRecipe(new ItemStack(DMermerB, 4), "xx", "xx", 'x', DMermer);
    ModLoader.addRecipe(new ItemStack(EMermerB, 4), "xx", "xx", 'x', EMermer);
    ModLoader.addRecipe(new ItemStack(FMermerB, 4), "xx", "xx", 'x', FMermer);
    ModLoader.addRecipe(new ItemStack(GMermerB, 4), "xx", "xx", 'x', GMermer);
    ModLoader.addRecipe(new ItemStack(HMermerB, 4), "xx", "xx", 'x', HMermer);
    ModLoader.addRecipe(new ItemStack(IMermerB, 4), "xx", "xx", 'x', IMermer);
    ModLoader.addRecipe(new ItemStack(JMermerB, 4), "xx", "xx", 'x', JMermer);
    ModLoader.addRecipe(new ItemStack(KMermerB, 4), "xx", "xx", 'x', KMermer);
    ModLoader.addRecipe(new ItemStack(LMermerB, 4), "xx", "xx", 'x', LMermer);
    ModLoader.addRecipe(new ItemStack(MMermerB, 4), "xx", "xx", 'x', MMermer);
    ModLoader.addRecipe(new ItemStack(NMermerB, 4), "xx", "xx", 'x', NMermer);
    ModLoader.addRecipe(new ItemStack(OMermerB, 4), "xx", "xx", 'x', OMermer);
    ModLoader.addRecipe(
        new ItemStack(Deneme, 1),
        "xxx",
        "yzy",
        "xxx",
        'x',
        SteelIngot,
        'y',
        Block.pistonBase,
        'z',
        Block.stone);
    ModLoader.addRecipe(
        new ItemStack(Batery, 1),
        " x ",
        "yzy",
        "yzy",
        'x',
        CopperCable,
        'y',
        SteelIngot,
        'z',
        Item.redstone);
    ModLoader.addRecipe(
        new ItemStack(SteelIngot, 1), " x ", "xyx", " x ", 'x', Item.coal, 'y', Item.ingotIron);
    ModLoader.addSmelting(CopperOre.blockID, new ItemStack(CopperIngot, 1), 2.0f);
    ModLoader.addShapelessRecipe(new ItemStack(SteelIngot, 2), Item.ingotIron, CopperIngot);
    TickRegistry.registerTickHandler(new TickHandler(), Side.SERVER);
  }
Exemple #28
0
 public GuiHandler() {
   NetworkRegistry.instance().registerGuiHandler(EJ.core.EJ.instance, this);
 }
  @Init
  public void load(FMLInitializationEvent evt) {

    initIC2Plugin();
    inituEPlugin();
    initbuildcraftPlugin();

    GameRegistry.registerBlock(MFFSMonazitOre);
    GameRegistry.registerBlock(MFFSFieldblock);
    GameRegistry.registerTileEntity(TileEntityForceField.class, "MFFSForceField");

    MFFSRecipes.init();

    MFFSMaschines.initialize();
    ProjectorTyp.initialize();
    ProjectorOptions.initialize();

    NetworkRegistry.instance().registerGuiHandler(instance, proxy);

    proxy.registerRenderInformation();
    proxy.registerTileEntitySpecialRenderer();

    GameRegistry.registerWorldGenerator(new MFFSWorldGenerator());

    LanguageRegistry.instance()
        .addNameForObject(MFFSitemInfinitePowerCard, "en_US", "Infinite Power Card");

    LanguageRegistry.instance()
        .addNameForObject(MFFSitemupgradeexctractorboost, "en_US", "MFFS Extractor Booster");
    LanguageRegistry.instance().addNameForObject(MFFSMonazitOre, "en_US", "Monazit Ore");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemForcicumCell, "en_US", "MFFS compact Forcicium Cell");
    LanguageRegistry.instance().addNameForObject(MFFSitemForcicium, "en_US", "Forcicium");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemForcePowerCrystal, "en_US", "MFFS Force Energy Crystal");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemSwitch, "en_US", "MFFS MultiTool <Switch>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemWrench, "en_US", "MFFS MultiTool <Wrench>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemManuelBook, "en_US", "MFFS MultiTool <Guide>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemFocusmatix, "en_US", "MFFS Projector Focus Matrix");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemFieldTeleporter, "en_US", "MFFS MultiTool <Field Teleporter>");

    LanguageRegistry.instance()
        .addNameForObject(MFFSAccessCard, "en_US", "MFFS Card <Access license> ");
    LanguageRegistry.instance().addNameForObject(MFFSitemcardempty, "en_US", "MFFS Card <blank> ");
    LanguageRegistry.instance().addNameForObject(MFFSitemfc, "en_US", "MFFS Card <Power Link>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSItemIDCard, "en_US", "MFFS Card <Personal ID>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSItemSecLinkCard, "en_US", "MFFS Card <Security Station Link> ");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemMFDdebugger, "en_US", "MFFS MultiTool <Debugger>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemMFDidtool, "en_US", "MFFS MultiTool <ID-Card Coder>");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemupgradecaprange, "en_US", "MFFS Capacitor Upgrade <Range> ");
    LanguageRegistry.instance()
        .addNameForObject(MFFSitemupgradecapcap, "en_US", "MFFS Capacitor Upgrade <Capacity> ");

    LanguageRegistry.instance()
        .addNameForObject(
            MFFSProjectorFFDistance, "en_US", "MFFS Projector Field Modulator <distance>");
    LanguageRegistry.instance()
        .addNameForObject(
            MFFSProjectorFFStrenght, "en_US", "MFFS Projector Field Modulator <strength>");

    LanguageRegistry.instance()
        .addStringLocalization("itemGroup.MFFS", "en_US", "Modular Force Field System");

    LanguageRegistry.instance()
        .addStringLocalization(
            "death.areaDefense", "en_US", "%1$s disregarded warnings and was fried");
    LanguageRegistry.instance()
        .addStringLocalization("death.fieldShock", "en_US", "%1$s was fried by a forcefield");
    LanguageRegistry.instance()
        .addStringLocalization("death.fieldDefense", "en_US", "%1$s was fried");
  }
Exemple #30
0
 public static void buildGuiHelper(BaseModProxy mod, int id) {
   ModLoaderGuiHelper handler = new ModLoaderGuiHelper(mod, id);
   guiHelpers.put(id, handler);
   NetworkRegistry.instance().registerGuiHandler(mod, handler);
 }