コード例 #1
0
ファイル: CommonIds.java プロジェクト: HedbergMartin/mFC
/**
 * Project: mFC
 *
 * <p>Class: CommonIds
 *
 * @author v3XzZ
 * @license Lesser GNU Public License v3 (http://www.gnu.org/licenses/lgpl.html)
 */
public class CommonIds {

  public static final int GUI_KEG = 87;
  public static final int GUI_SHELF = 88;

  public static EnumToolMaterial TOOL_OBSIDIAN =
      EnumHelper.addToolMaterial("OBSIDIAN", 2, 3000, 6F, 1F, 2);
  public static EnumToolMaterial TOOL_KNIFE =
      EnumHelper.addToolMaterial("KNIFE", 0, 200, 1.0F, 2.0F, 0);

  public static final byte PACKET_PLATE = 0;
  public static final byte PACKET_SHELF = 1;
  public static final byte PACKET_CAULDRON = 2;
  public static final byte PACKET_RENDER = 3;
  public static final byte PACKET_PLAYERDATA = 4;
  public static final byte PACKET_BARREL = 5;

  public static final String DRINK_BEER = "beer";
  public static final String DRINK_WHITEWINE = "whitewine";
  public static final String DRINK_REDWINE = "redwine";
  public static final String DRINK_JULMUST = "julmust";
  public static final String DRINK_WATER = "water";

  public static final int MAX_GRAIN_STACK = 4;

  public static final Integer[] appleColors = new Integer[] {0x75FF83, 0xFFE270, 0xFF0000};
  public static final Integer[] orangeColors = new Integer[] {0x008C00, 0x6BFF68, 0xFFD400};
  public static final Integer[] avocadoColors = new Integer[] {0x9DFF96, 0x74BC6F, 0x467043};
}
コード例 #2
0
public class RegistrySword {

  public static ArrayList<Sword> swords = new ArrayList<Sword>();
  public static EnumRarity legendary;
  public static int LEGENDARY = 0, ANCIENT = 1, COMMON = 2;
  public static EnumToolMaterial[] material = {
    EnumHelper.addToolMaterial("LEGENDARY", 3, 2000, 4F, 6, 10),
    EnumHelper.addToolMaterial("ANCIENT", 2, 225, 1.1F, 8, 40),
    EnumHelper.addToolMaterial("COMMON", 2, 250, 6F, 3, 18)
  };

  public RegistrySword() {
    MinecraftForgeClient.preloadTexture("/okushama/humansplus/swords.png");
    legendary = EnumHelperClient.addRarity("legendary", 5, "Legendary");
    // Sword Registration!
    add(846, "Hidden Blade", material[COMMON]);
    add(847, "Journeyman's Blade", material[COMMON]);
    add(848, "Ornate Blade", material[ANCIENT]);
    add(849, "Broken Blade", material[COMMON]);
    add(850, "Katana", material[COMMON]);
    add(851, "Devouros", material[ANCIENT]);
    add(852, "Gladios", material[ANCIENT]);
    add(853, "Lich Bane", material[ANCIENT]);
    add(854, "Bastard Sword", material[COMMON]);
    add(855, "Malaikah", material[ANCIENT]);
    add(856, "Aquatos", material[LEGENDARY]);
    add(857, "Infernos", material[LEGENDARY]);
    add(858, "Epachos", material[LEGENDARY]);
    add(859, "Solanis", material[LEGENDARY]);
    add(860, "Lunos", material[LEGENDARY]);
    add(861, "Mortis", material[LEGENDARY]);
  }

  public void add(int id, String name, EnumToolMaterial mat) {
    swords.add(new Sword(id, name, mat));
  }

  public static class Sword {
    public String swordName;
    public EnumToolMaterial material;
    public okushama.humansplus.Sword theSword;
    int id;

    public Sword(int i, String name, EnumToolMaterial equiv) {
      id = i;
      swordName = name;
      material = equiv;
      theSword =
          (okushama.humansplus.Sword)
              (new okushama.humansplus.Sword(id, material)
                  .setIconCoord(id - 846, 0)
                  .setItemName(swordName)
                  .setCreativeTab(CreativeTabs.tabCombat));
      LanguageRegistry.addName(theSword, swordName);
    }
  }
}
コード例 #3
0
 public static void initModEnumToolMaterial() {
   COPPER = EnumHelper.addToolMaterial("COPPER", 1, 156, 4.5F, 1, 10);
   TIN = EnumHelper.addToolMaterial("TIN", 1, 198, 5.0F, 2, 12);
   ALUMINIUM = EnumHelper.addToolMaterial("ALUMINIUM", 1, 16, 1.0F, 2, 12);
   ZINC = EnumHelper.addToolMaterial("ZINC", 1, 234, 5.5F, 2, 10);
   SILVER = EnumHelper.addToolMaterial("SILVER", 2, 963, 7.0F, 2, 18);
   OBSIDIAN = EnumHelper.addToolMaterial("OBSIDIAN", 3, 2341, 5.0F, 2, 4);
   BRONZE = EnumHelper.addToolMaterial("BRONZE", 2, 531, 6.0F, 2, 12);
   BRASS = EnumHelper.addToolMaterial("BRASS", 2, 752, 6.5F, 2, 14);
 }
コード例 #4
0
// Just Some Basic Info
@Mod(
    modid = "hazzachooks_star_wars_addon",
    name = "Hazzchooks Star Wars Mod Addon",
    version = "1.0.1-Pre-Alpha")
@NetworkMod(clientSideRequired = true, serverSideRequired = false)
public class StarWarsAddon_Core {

  // Creative Tab
  public static CreativeTabs hazzachooks_star_wars_addon_tab;

  // Our Items
  public static Item darkBlade;

  // Mob ID's
  static int startEntityId = 300;

  // Enum Material
  public static EnumToolMaterial dark_blade_enum =
      EnumHelper.addToolMaterial("dark_blade_enum", 3, 1507, 8.0F, 4.0F, 0);

  // Mob Generation
  public static int getUniqueEntityId() {
    do {
      startEntityId++;
    } while (EntityList.getStringFromID(startEntityId) != null);
    return startEntityId++;
  }

  public static void registerEntityEgg(
      Class<? extends Entity> entity, int primaryColor, int secondaryColor) {
    int id = getUniqueEntityId();
    EntityList.IDtoClassMapping.put(id, entity);
    EntityList.entityEggs.put(id, new EntityEggInfo(id, primaryColor, secondaryColor));
  }

  @EventHandler
  public void Load(FMLPreInitializationEvent Event) {

    // Settings For Our Creative Tab
    hazzachooks_star_wars_addon_tab =
        new CreativeTabs("hazzachooks_star_wars_addon_tab") {
          public ItemStack getIconItemStack() {
            return new ItemStack(darkBlade, 1, 0);
          }
        };
    LanguageRegistry.instance()
        .addStringLocalization(
            "itemGroup.hazzachooks_star_wars_addon_tab",
            "en_US",
            "Hazzachooks Star Wars Addon Tab");

    // Settings For Our Items
    darkBlade =
        new DarkBlade(2000, dark_blade_enum)
            .setUnlocalizedName("dark blade")
            .setCreativeTab(this.hazzachooks_star_wars_addon_tab);

    // Settings For Our Mobs
    EntityRegistry.registerGlobalEntityID(Entity_deathwatch.class, "Deathwatch", 1);
    EntityRegistry.addSpawn(Entity_deathwatch.class, 20, 5, 20, EnumCreatureType.monster);
    EntityRegistry.findGlobalUniqueEntityId();
    registerEntityEgg(Entity_deathwatch.class, 0xF1EDED, 0x0020C2);
    RenderingRegistry.registerEntityRenderingHandler(
        Entity_deathwatch.class, new Renderdeathwatch(new Model_deathwatch(), 0.3F));
    EntityRegistry.registerGlobalEntityID(Entity_pre_vizsla.class, "Pre-Vizsla", 1);
    EntityRegistry.addSpawn(Entity_pre_vizsla.class, 20, 5, 20, EnumCreatureType.monster);
    registerEntityEgg(Entity_pre_vizsla.class, 0xF1EDED, 0x0020C2);
    RenderingRegistry.registerEntityRenderingHandler(
        Entity_pre_vizsla.class, new Renderprevizsla(new Model_pre_vizsla(), 0.3F));

    // Register Our Items
    GameRegistry.registerItem(darkBlade, "darkBlade");
    LanguageRegistry.addName(darkBlade, "Dark Saber");
  }
}
コード例 #5
0
/**
 * @author Azanor
 *     <p>IMPORTANT: If you are adding your own aspects to items it is a good idea to do it AFTER
 *     Thaumcraft adds its aspects, otherwise odd things may happen.
 */
public class ThaumcraftApi {

  // Materials
  public static EnumToolMaterial toolMatThaumium =
      EnumHelper.addToolMaterial("THAUMIUM", 3, 400, 7F, 2, 22);
  public static EnumToolMaterial toolMatElemental =
      EnumHelper.addToolMaterial("THAUMIUM_ELEMENTAL", 3, 1500, 10F, 3, 18);
  public static EnumArmorMaterial armorMatThaumium =
      EnumHelper.addArmorMaterial("THAUMIUM", 25, new int[] {2, 6, 5, 2}, 25);
  public static EnumArmorMaterial armorMatSpecial =
      EnumHelper.addArmorMaterial("SPECIAL", 25, new int[] {1, 3, 2, 1}, 25);

  // Miscellaneous
  /**
   * Portable Hole Block-id Blacklist. Simply add the block-id's of blocks you don't want the
   * portable hole to go through.
   */
  public static ArrayList<Integer> portableHoleBlackList = new ArrayList<Integer>();

  // RESEARCH/////////////////////////////////////////
  public static Document researchDoc = null;
  public static ArrayList<String> apiResearchFiles = new ArrayList<String>();
  public static ArrayList<IScanEventHandler> scanEventhandlers = new ArrayList<IScanEventHandler>();

  /**
   * Used to add your own xml files that the research system will check of recipes and descriptions
   * of custom research
   *
   * @param resourceLoc The xml file. For example The default file used by TC is
   *     "/thaumcraft/resources/research.xml"
   */
  public static void registerResearchXML(String resourceLoc) {
    if (!apiResearchFiles.contains(resourceLoc)) apiResearchFiles.add(resourceLoc);
  }

  public static void registerScanEventhandler(IScanEventHandler scanEventHandler) {
    scanEventhandlers.add(scanEventHandler);
  }

  // RECIPES/////////////////////////////////////////
  private static ArrayList crucibleRecipes = new ArrayList();
  private static List craftingRecipes = new ArrayList();
  private static HashMap<List, ItemStack> smeltingBonus = new HashMap<List, ItemStack>();
  private static ArrayList<List> smeltingBonusExlusion = new ArrayList<List>();

  /**
   * This method is used to determine what bonus items are generated when the infernal furnace
   * smelts items
   *
   * @param in The result (not input) of the smelting operation. e.g. new ItemStack(ingotGold)
   * @param out The bonus item that can be produced from the smelting operation e.g. new
   *     ItemStack(nuggetGold,0,0). Stacksize should be 0 unless you want to guarantee that at least
   *     1 item is always produced.
   */
  public static void addSmeltingBonus(ItemStack in, ItemStack out) {
    smeltingBonus.put(
        Arrays.asList(in.itemID, in.getItemDamage()),
        new ItemStack(out.itemID, 0, out.getItemDamage()));
  }

  /**
   * Returns the bonus item produced from a smelting operation in the infernal furnace
   *
   * @param in The result of the smelting operation. e.g. new ItemStack(ingotGold)
   * @return the The bonus item that can be produced
   */
  public static ItemStack getSmeltingBonus(ItemStack in) {
    return smeltingBonus.get(Arrays.asList(in.itemID, in.getItemDamage()));
  }

  /**
   * Excludes specific items from producing bonus items when they are smelted in the infernal
   * furnace, even if their smelt result would normally produce a bonus item.
   *
   * @param in The item to be smelted that should never produce a bonus item (e.g. the various
   *     macerated dusts form IC2) Even though they produce gold, iron, etc. ingots, they should NOT
   *     produce bonus nuggets as well.
   */
  public static void addSmeltingBonusExclusion(ItemStack in) {
    smeltingBonusExlusion.add(Arrays.asList(in.itemID, in.getItemDamage()));
  }

  /**
   * Sees if an item is allowed to produce bonus items when smelted in the infernal furnace
   *
   * @param in The item you wish to check
   * @return true or false
   */
  public static boolean isSmeltingBonusExluded(ItemStack in) {
    return smeltingBonusExlusion.contains(Arrays.asList(in.itemID, in.getItemDamage()));
  }

  public static List getCraftingRecipes() {
    return craftingRecipes;
  }

  /**
   * NOTE: All arcane and infusion crafting recipes are NBT sensitive. Simply add as much nbt data
   * to the crafting ingredient itemstacks as you wish to match with the actual input items. For
   * example this recipe will turn a warded jar filled with crystal essentia into a stack of
   * diamonds:
   *
   * <p>ItemStack is = new ItemStack(itemJarFilled); is.setTagInfo("tag", new NBTTagByte("tag",
   * (byte) EnumTag.CRYSTAL.id)); is.setTagInfo("amount", new NBTTagByte("amount", (byte) 64));
   * ThaumcraftApi.addShapelessArcaneCraftingRecipe("THEJARISNOWDIAMONDS", 50, new
   * ItemStack(Item.diamond,64,0), new Object[] { is });
   *
   * <p>If no tag was added for "amount" then the jar would simply have had to contain any amount of
   * crystal essentia.
   */

  /**
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param cost the vis cost
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla recipes
   */
  public static void addArcaneCraftingRecipe(
      String key, int cost, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    String var3 = "";
    int var4 = 0;
    int var5 = 0;
    int var6 = 0;
    int var9;

    if (par2ArrayOfObj[var4] instanceof String[]) {
      String[] var7 = (String[]) ((String[]) par2ArrayOfObj[var4++]);
      String[] var8 = var7;
      var9 = var7.length;

      for (int var10 = 0; var10 < var9; ++var10) {
        String var11 = var8[var10];
        ++var6;
        var5 = var11.length();
        var3 = var3 + var11;
      }
    } else {
      while (par2ArrayOfObj[var4] instanceof String) {
        String var13 = (String) par2ArrayOfObj[var4++];
        ++var6;
        var5 = var13.length();
        var3 = var3 + var13;
      }
    }

    HashMap var14;

    for (var14 = new HashMap(); var4 < par2ArrayOfObj.length; var4 += 2) {
      Character var16 = (Character) par2ArrayOfObj[var4];
      ItemStack var17 = null;

      if (par2ArrayOfObj[var4 + 1] instanceof Item) {
        var17 = new ItemStack((Item) par2ArrayOfObj[var4 + 1]);
      } else if (par2ArrayOfObj[var4 + 1] instanceof Block) {
        var17 = new ItemStack((Block) par2ArrayOfObj[var4 + 1], 1, -1);
      } else if (par2ArrayOfObj[var4 + 1] instanceof ItemStack) {
        var17 = (ItemStack) par2ArrayOfObj[var4 + 1];
      }

      var14.put(var16, var17);
    }

    ItemStack[] var15 = new ItemStack[var5 * var6];

    for (var9 = 0; var9 < var5 * var6; ++var9) {
      char var18 = var3.charAt(var9);

      if (var14.containsKey(Character.valueOf(var18))) {
        var15[var9] = ((ItemStack) var14.get(Character.valueOf(var18))).copy();
      } else {
        var15[var9] = null;
      }
    }

    craftingRecipes.add(
        new ShapedArcaneCraftingRecipes(key, var5, var6, var15, par1ItemStack, cost));
  }

  /**
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param recipeKey a string value of the key used in your research.xml for this recipe to display
   *     in the thaumonomicon
   * @param cost the vis cost
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla recipes
   */
  public static void addArcaneCraftingRecipe(
      String key, String recipeKey, int cost, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    addArcaneCraftingRecipe(key, cost, par1ItemStack, par2ArrayOfObj);
    ResearchList.craftingRecipesForResearch.put(
        recipeKey, Arrays.asList(getCraftingRecipes().size() - 1));
  }

  /**
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param cost the vis cost
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla shapeless recipes
   */
  public static void addShapelessArcaneCraftingRecipe(
      String key, int cost, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    ArrayList var3 = new ArrayList();
    Object[] var4 = par2ArrayOfObj;
    int var5 = par2ArrayOfObj.length;

    for (int var6 = 0; var6 < var5; ++var6) {
      Object var7 = var4[var6];

      if (var7 instanceof ItemStack) {
        var3.add(((ItemStack) var7).copy());
      } else if (var7 instanceof Item) {
        var3.add(new ItemStack((Item) var7));
      } else {
        if (!(var7 instanceof Block)) {
          throw new RuntimeException("Invalid shapeless recipe!");
        }

        var3.add(new ItemStack((Block) var7));
      }
    }

    craftingRecipes.add(new ShapelessArcaneCraftingRecipes(key, par1ItemStack, var3, cost));
  }

  /**
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param recipeKey a string value of the key used in your research.xml for this recipe to display
   *     in the thaumonomicon
   * @param cost the vis cost
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla shapeless recipes
   */
  public static void addShapelessArcaneCraftingRecipe(
      String key, String recipeKey, int cost, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    addShapelessArcaneCraftingRecipe(key, cost, par1ItemStack, par2ArrayOfObj);
    ResearchList.craftingRecipesForResearch.put(
        recipeKey, Arrays.asList(getCraftingRecipes().size() - 1));
  }

  /**
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param cost the vis cost
   * @param tags ObjectTags list of required aspects and their amounts. No more than 5 aspects
   *     should be used in a recipe.
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla recipes
   */
  public static void addInfusionCraftingRecipe(
      String key, int cost, ObjectTags tags, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    String var3 = "";
    int var4 = 0;
    int var5 = 0;
    int var6 = 0;
    int var9;

    if (par2ArrayOfObj[var4] instanceof String[]) {
      String[] var7 = (String[]) ((String[]) par2ArrayOfObj[var4++]);
      String[] var8 = var7;
      var9 = var7.length;

      for (int var10 = 0; var10 < var9; ++var10) {
        String var11 = var8[var10];
        ++var6;
        var5 = var11.length();
        var3 = var3 + var11;
      }
    } else {
      while (par2ArrayOfObj[var4] instanceof String) {
        String var13 = (String) par2ArrayOfObj[var4++];
        ++var6;
        var5 = var13.length();
        var3 = var3 + var13;
      }
    }

    HashMap var14;

    for (var14 = new HashMap(); var4 < par2ArrayOfObj.length; var4 += 2) {
      Character var16 = (Character) par2ArrayOfObj[var4];
      ItemStack var17 = null;

      if (par2ArrayOfObj[var4 + 1] instanceof Item) {
        var17 = new ItemStack((Item) par2ArrayOfObj[var4 + 1]);
      } else if (par2ArrayOfObj[var4 + 1] instanceof Block) {
        var17 = new ItemStack((Block) par2ArrayOfObj[var4 + 1], 1, -1);
      } else if (par2ArrayOfObj[var4 + 1] instanceof ItemStack) {
        var17 = (ItemStack) par2ArrayOfObj[var4 + 1];
      }

      var14.put(var16, var17);
    }

    ItemStack[] var15 = new ItemStack[var5 * var6];

    for (var9 = 0; var9 < var5 * var6; ++var9) {
      char var18 = var3.charAt(var9);

      if (var14.containsKey(Character.valueOf(var18))) {
        var15[var9] = ((ItemStack) var14.get(Character.valueOf(var18))).copy();
      } else {
        var15[var9] = null;
      }
    }

    craftingRecipes.add(
        new ShapedInfusionCraftingRecipes(key, var5, var6, var15, par1ItemStack, cost, tags));
  }

  /**
   * Recipe is NBT sensitive
   *
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param recipeKey a string value of the key used in your research.xml for this recipe to display
   *     in the thaumonomicon
   * @param cost the vis cost
   * @param tags ObjectTags list of required aspects and their amounts. No more than 5 aspects
   *     should be used in a recipe.
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla recipes
   */
  public static void addInfusionCraftingRecipe(
      String key,
      String recipeKey,
      int cost,
      ObjectTags tags,
      ItemStack par1ItemStack,
      Object... par2ArrayOfObj) {
    addInfusionCraftingRecipe(key, cost, tags, par1ItemStack, par2ArrayOfObj);
    ResearchList.craftingRecipesForResearch.put(
        recipeKey, Arrays.asList(getCraftingRecipes().size() - 1));
  }

  /**
   * Recipe is NBT sensitive
   *
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param cost the vis cost
   * @param tags ObjectTags list of required aspects and their amounts. No more than 5 aspects
   *     should be used in a recipe.
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla shapeless recipes
   */
  public static void addShapelessInfusionCraftingRecipe(
      String key, int cost, ObjectTags tags, ItemStack par1ItemStack, Object... par2ArrayOfObj) {
    ArrayList var3 = new ArrayList();
    Object[] var4 = par2ArrayOfObj;
    int var5 = par2ArrayOfObj.length;

    for (int var6 = 0; var6 < var5; ++var6) {
      Object var7 = var4[var6];

      if (var7 instanceof ItemStack) {
        var3.add(((ItemStack) var7).copy());
      } else if (var7 instanceof Item) {
        var3.add(new ItemStack((Item) var7));
      } else {
        if (!(var7 instanceof Block)) {
          throw new RuntimeException("Invalid shapeless recipe!");
        }

        var3.add(new ItemStack((Block) var7));
      }
    }

    craftingRecipes.add(new ShapelessInfusionCraftingRecipes(key, par1ItemStack, var3, cost, tags));
  }

  /**
   * Recipe is NBT sensitive
   *
   * @param key the research key required for this recipe to work. Leave blank if it will work
   *     without research
   * @param recipeKey a string value of the key used in your research.xml for this recipe to display
   *     in the thaumonomicon
   * @param cost the vis cost
   * @param tags ObjectTags list of required aspects and their amounts. No more than 5 aspects
   *     should be used in a recipe.
   * @param par1ItemStack the recipe output
   * @param par2ArrayOfObj the recipe. Format is exactly the same as vanilla shapeless recipes
   */
  public static void addShapelessInfusionCraftingRecipe(
      String key,
      String recipeKey,
      int cost,
      ObjectTags tags,
      ItemStack par1ItemStack,
      Object... par2ArrayOfObj) {
    addShapelessInfusionCraftingRecipe(key, cost, tags, par1ItemStack, par2ArrayOfObj);
    ResearchList.craftingRecipesForResearch.put(
        recipeKey, Arrays.asList(getCraftingRecipes().size() - 1));
  }

  /**
   * @param key the research key required for this recipe to work. Unlike the arcane crafting and
   *     infusion crafting recipes a recipe key is automatically created using the same key. See
   *     method below if the research and recipes keys do not match
   * @param result the output result
   * @param cost the vis cost
   * @param tags the aspects required to craft this
   */
  public static void addCrucibleRecipe(String key, ItemStack result, int cost, ObjectTags tags) {
    getCrucibleRecipes().add(new RecipeCrucible(key, result, tags, cost));
  }

  /**
   * @param key the research key required for this recipe to work.
   * @param recipeKey a string value of the key used in your research.xml for this recipe to display
   *     in the thaumonomicon
   * @param result the output result
   * @param cost the vis cost
   * @param tags the aspects required to craft this
   */
  public static void addCrucibleRecipe(
      String key, String recipeKey, ItemStack result, int cost, ObjectTags tags) {
    getCrucibleRecipes().add(new RecipeCrucible(key, recipeKey, result, tags, cost));
  }

  /**
   * @param key the recipe key (NOT research key)
   * @return the recipe
   */
  public static RecipeCrucible getCrucibleRecipe(String key) {
    for (Object r : getCrucibleRecipes()) {
      if (r instanceof RecipeCrucible) {
        if (((RecipeCrucible) r).key.equals(key)) return (RecipeCrucible) r;
      }
    }
    return null;
  }

  /**
   * @param stack the recipe result
   * @return the recipe
   */
  public static RecipeCrucible getCrucibleRecipe(ItemStack stack) {
    for (Object r : getCrucibleRecipes()) {
      if (r instanceof RecipeCrucible) {
        if (((RecipeCrucible) r).recipeOutput.isItemEqual(stack)) return (RecipeCrucible) r;
      }
    }
    return null;
  }

  /**
   * @param stack the item
   * @return the thaumcraft recipe key that produces that item. Used by the thaumonomicon drilldown
   *     feature.
   */
  public static String getCraftingRecipeKey(ItemStack stack) {
    for (Object r : getCraftingRecipes()) {
      if (r instanceof IArcaneRecipe) {
        if (ThaumcraftApiHelper.areItemsEqual(stack, ((IArcaneRecipe) r).getRecipeOutput()))
          return ((IArcaneRecipe) r).getKey();
      }
      if (r instanceof IInfusionRecipe) {
        if (ThaumcraftApiHelper.areItemsEqual(stack, ((IInfusionRecipe) r).getRecipeOutput()))
          return ((IInfusionRecipe) r).getKey();
      }
    }
    return "";
  }

  // TAGS////////////////////////////////////////

  public static Map<List, ObjectTags> objectTags = new HashMap<List, ObjectTags>();

  /**
   * Checks to see if the passed item/block already has aspects associated with it.
   *
   * @param id
   * @param meta
   * @return
   */
  public static boolean exists(int id, int meta) {
    ObjectTags tmp = ThaumcraftApi.objectTags.get(Arrays.asList(id, meta));
    if (tmp == null) {
      tmp = ThaumcraftApi.objectTags.get(Arrays.asList(id, -1));
      if (meta == -1 && tmp == null) {
        int index = 0;
        do {
          tmp = ThaumcraftApi.objectTags.get(Arrays.asList(id, index));
          index++;
        } while (index < 16 && tmp == null);
      }
      if (tmp == null) return false;
    }

    return true;
  }

  /**
   * Used to assign apsects to the given item/block. Here is an example of the declaration for
   * cobblestone:
   *
   * <p><i>ThaumcraftApi.registerObjectTag(Block.cobblestone.blockID, -1, (new
   * ObjectTags()).add(EnumTag.ROCK, 1).add(EnumTag.DESTRUCTION, 1));</i>
   *
   * @param id
   * @param meta pass -1 if all damage values of this item/block should have the same aspects
   * @param aspects A ObjectTags object of the associated aspects
   */
  public static void registerObjectTag(int id, int meta, ObjectTags aspects) {
    aspects = ThaumcraftApiHelper.cullTags(aspects);
    objectTags.put(Arrays.asList(id, meta), aspects);
  }

  /**
   * Used to assign aspects to the given item/block. Attempts to automatically generate aspect tags
   * by checking registered recipes. Here is an example of the declaration for pistons:
   *
   * <p><i>ThaumcraftApi.registerComplexObjectTag(Block.pistonBase.blockID, 0, (new
   * ObjectTags()).add(EnumTag.MECHANISM, 2).add(EnumTag.MOTION, 4));</i>
   *
   * @param id
   * @param meta pass -1 if all damage values of this item/block should have the same aspects
   * @param aspects A ObjectTags object of the associated aspects
   */
  public static void registerComplexObjectTag(int id, int meta, ObjectTags aspects) {
    if (!exists(id, meta)) {
      ObjectTags tmp = ThaumcraftApiHelper.generateTags(id, meta);
      if (tmp != null && tmp.size() > 0) {
        for (EnumTag tag : tmp.getAspects()) {
          aspects.add(tag, tmp.getAmount(tag));
        }
      }
      registerObjectTag(id, meta, aspects);
    } else {
      ObjectTags tmp = ThaumcraftApiHelper.getObjectTags(new ItemStack(id, 1, meta));
      for (EnumTag tag : aspects.getAspects()) {
        tmp.merge(tag, tmp.getAmount(tag));
      }
      registerObjectTag(id, meta, tmp);
    }
  }

  public static ArrayList getCrucibleRecipes() {
    return crucibleRecipes;
  }

  // AURAS//////////////////////////////////////////////////

  private static Method addFluxToClosest;
  /**
   * Adds flux to the node closest to the given location
   *
   * @param world
   * @param x
   * @param y
   * @param z
   * @param tags ObjectTags list of all the EnumTags and amounts of flux to add.
   */
  public static void addFluxToClosest(World world, float x, float y, float z, ObjectTags tags) {
    try {
      if (addFluxToClosest == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        addFluxToClosest =
            fake.getMethod(
                "addFluxToClosest",
                World.class,
                float.class,
                float.class,
                float.class,
                ObjectTags.class);
      }
      addFluxToClosest.invoke(null, world, x, y, z, tags);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method addFluxToClosest");
    }
  }

  private static Method decreaseClosestAura;
  /**
   * Removes an amount of vis from the aura node closest to the given location
   *
   * @param world
   * @param x
   * @param y
   * @param z
   * @param amount The amount of vis to remove
   * @param doit If set to false it will merely perform a check to see if there is enough vis to
   *     perform the operation. If set to true it will actually decrease the vis as well.
   * @return It will return true if there was enough vis to perform this operation
   */
  public static boolean decreaseClosestAura(
      World world, double x, double y, double z, int amount, boolean doit) {
    boolean ret = false;
    try {
      if (decreaseClosestAura == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        decreaseClosestAura =
            fake.getMethod(
                "decreaseClosestAura",
                World.class,
                double.class,
                double.class,
                double.class,
                int.class,
                boolean.class);
      }
      ret = (Boolean) decreaseClosestAura.invoke(null, world, x, y, z, amount, doit);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method decreaseClosestAura");
    }
    return ret;
  }

  private static Method increaseLowestAura;
  /**
   * Increases the lowest aura near the given location.
   *
   * @param world
   * @param x
   * @param y
   * @param z
   * @param amount
   * @return it will return true if the operation was a success
   */
  public static boolean increaseLowestAura(World world, double x, double y, double z, int amount) {
    boolean ret = false;
    try {
      if (increaseLowestAura == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        increaseLowestAura =
            fake.getMethod(
                "increaseLowestAura",
                World.class,
                double.class,
                double.class,
                double.class,
                int.class);
      }
      ret = (Boolean) increaseLowestAura.invoke(null, world, x, y, z, amount);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method increaseLowestAura");
    }
    return ret;
  }

  private static Method getClosestAuraWithinRange;
  /**
   * Gets the id of the closest aura node within range of the given coordinates. Only checks loaded
   * chunks
   *
   * @param world
   * @param x
   * @param y
   * @param z
   * @param range distance (in blocks) to check
   * @return returns -1 if no aura is found, otherwise returns the aura node id.
   */
  public static int getClosestAuraWithinRange(
      World world, double x, double y, double z, double range) {
    int ret = -1;
    try {
      if (getClosestAuraWithinRange == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        getClosestAuraWithinRange =
            fake.getMethod(
                "getClosestAuraWithinRange",
                World.class,
                double.class,
                double.class,
                double.class,
                double.class);
      }
      ret = (Integer) getClosestAuraWithinRange.invoke(null, world, x, y, z, range);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method getClosestAuraWithinRange");
    }
    return ret;
  }

  private static Method getNodeCopy;
  /**
   * Gets an copy of the AuraNode object for the given node
   *
   * @param nodeId the int key of the aura node
   * @return returns a COPY of the auranode object, not the object itself. Auranode values should
   *     only be altered via queNodeChanges - NEVER directly
   */
  public static AuraNode getNodeCopy(int nodeId) {
    AuraNode node = null;
    try {
      if (getNodeCopy == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        getNodeCopy = fake.getMethod("getNodeCopy", int.class);
      }
      node = (AuraNode) getNodeCopy.invoke(null, nodeId);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method getNodeCopy");
    }
    return node;
  }

  private static Method queueNodeChanges;
  /**
   * This method is used to alter the values of aura nodes. The changes specified are placed in a
   * queue for processing by the aura thread.<br>
   * For example:<br>
   * queNodeChanges(55,8,0,false,null,0,0,0); //will increase node 55's current vis by 8<br>
   * queNodeChanges(55,0,0,false,new ObjectTags().remove(EnumTag.FIRE,3),0,0,0); //will reduce node
   * 55's FIRE flux levels by 3<br>
   * queNodeChanges(55,11,11,false,null,0,.5f,0); //will increase node 55's current and base level
   * by 11 and increase its y pos by .5f<br>
   *
   * @param nodeId
   * @param levelMod the amount by which the auras vis level should be changed (positive or
   *     negative)
   * @param baseMod the amount by which the auras max vis level should be changed (positive or
   *     negative)
   * @param toggleLock if set to true the nodes lock state will toggle to its opposite value.
   *     Currently doesn't do much
   * @param flx a ObjectTags collection of the all the flux to add (if positive) or remove (if
   *     negative) to the node
   * @param x by how much the nodes x position should be altered. Should usually be less than 1
   * @param y by how much the nodes y position should be altered. Should usually be less than 1
   * @param z by how much the nodes z position should be altered. Should usually be less than 1
   */
  public static void queueNodeChanges(
      int nodeId,
      int levelMod,
      int baseMod,
      boolean toggleLock,
      ObjectTags flux,
      float x,
      float y,
      float z) {
    try {
      if (queueNodeChanges == null) {
        Class fake = Class.forName("thaumcraft.common.aura.AuraManager");
        queueNodeChanges =
            fake.getMethod(
                "queueNodeChanges",
                int.class,
                int.class,
                int.class,
                boolean.class,
                ObjectTags.class,
                float.class,
                float.class,
                float.class);
      }
      queueNodeChanges.invoke(null, nodeId, levelMod, baseMod, toggleLock, flux, x, y, z);
    } catch (Exception ex) {
      FMLLog.warning(
          "[Thaumcraft API] Could not invoke thaumcraft.common.aura.AuraManager method queueNodeChanges");
    }
  }

  // BIOMES//////////////////////////////////////////////////
  @Deprecated public static HashMap<Integer, List> biomeInfo = new HashMap<Integer, List>();

  /**
   * Registers custom biomes with thaumcraft @Deprecated I will be switching over the the forge
   * BiomeDictionary system in the future so any mods that add biomes should just make sure they are
   * tagged correctly
   *
   * @param biomeID The id of the biome
   * @param visLevel The average vis level of nodes generated in this biome
   * @param tag The EnumTag associated with this biome (used to determine infused ore spawns among
   *     other things)
   * @param greatwood Does this biome support greatwood trees
   * @param silverwood Does this biome support silverwood trees
   */
  @Deprecated
  public static void registerBiomeInfo(
      int biomeID, int visLevel, EnumTag tag, boolean greatwood, boolean silverwood) {
    biomeInfo.put(biomeID, Arrays.asList(visLevel, tag, greatwood, silverwood));
  }

  @Deprecated
  public static int getBiomeAura(int biomeId) {
    try {
      return (Integer) biomeInfo.get(biomeId).get(0);
    } catch (Exception e) {
    }
    return 200;
  }

  @Deprecated
  public static EnumTag getBiomeTag(int biomeId) {
    try {
      return (EnumTag) biomeInfo.get(biomeId).get(1);
    } catch (Exception e) {
    }
    return EnumTag.UNKNOWN;
  }

  @Deprecated
  public static boolean getBiomeSupportsGreatwood(int biomeId) {
    try {
      return (Boolean) biomeInfo.get(biomeId).get(2);
    } catch (Exception e) {
    }
    return false;
  }

  @Deprecated
  public static boolean getBiomeSupportsSilverwood(int biomeId) {
    try {
      return (Boolean) biomeInfo.get(biomeId).get(3);
    } catch (Exception e) {
    }
    return false;
  }

  // CROPS
  // //////////////////////////////////////////////////////////////////////////////////////////

  /**
   * To define mod crops you need to use FMLInterModComms in your @Mod.Init method. There are two
   * 'types' of crops you can add. Standard crops and clickable crops.
   *
   * <p>Standard crops work like normal vanilla crops - they grow until a certain metadata value is
   * reached and you harvest them by destroying the block and collecting the blocks. You need to
   * create and ItemStack that tells the golem what block id and metadata represents the crop when
   * fully grown. Example for vanilla wheat: FMLInterModComms.sendMessage("Thaumcraft",
   * "harvestStandardCrop", new ItemStack(Block.crops,1,7));
   *
   * <p>Clickable crops are crops that you right click to gather their bounty instead of destroying
   * them. As for standard crops, you need to create and ItemStack that tells the golem what block
   * id and metadata represents the crop when fully grown. The golem will trigger the blocks
   * onBlockActivated method. Example (this will technically do nothing since clicking wheat does
   * nothing, but you get the idea): FMLInterModComms.sendMessage("Thaumcraft",
   * "harvestClickableCrop", new ItemStack(Block.crops,1,7));
   */
  @Deprecated public static HashMap<Integer, Integer> crops = new HashMap<Integer, Integer>();

  /**
   * This is used to add mod crops to the list of crops harvested by golems that do not use the
   * standard crop growth pattern<br>
   * (i.e. being an instance of BlockCrops and being fully grown at meta 7).<br>
   * Only seeds implementing IPlantable will be replanted.
   *
   * @param blockID the block id of the crop
   * @param grownMeta the metadata value when the crop is considered fully grown. The block with
   *     this id and meta will be the one the golem breaks.
   */
  @Deprecated
  public static void addHarvestableCrop(int blockID, int grownMeta) {
    crops.put(blockID, grownMeta);
  }
}
コード例 #6
0
 static {
   EnumToolMaterial enumt = EnumHelper.addToolMaterial("pellep", 5, 2000, 5F, 5, 15);
   block = (Item) (new ItemSpade(804, enumt)).setUnlocalizedName("pelleOD");
 }
コード例 #7
0
  private void initBlazeTools() {
    /**
     * WOOD(0, 59, 2.0F, 0, 15), STONE(1, 131, 4.0F, 1, 5), IRON(2, 250, 6.0F, 2, 14), EMERALD(3,
     * 1561, 8.0F, 3, 10), GOLD(0, 32, 12.0F, 0, 22);
     */
    blazeToolMaterial = EnumHelper.addToolMaterial("BLAZEINGOT", 2, 1561, 6.0f, 2, 14);

    blazeSword =
        (new BlazeItemSword(DefaultProps.BLAZE_SWORD_ID, blazeToolMaterial))
            .setIconCoord(2, 0)
            .setItemName("blazesword");
    blazeShovel =
        (new BlazeItemShovel(DefaultProps.BLAZE_SHOVEL_ID, blazeToolMaterial))
            .setIconCoord(3, 0)
            .setItemName("blazeshovel");
    blazePickaxe =
        (new BlazeItemPickaxe(DefaultProps.BLAZE_PICKAXE_ID, blazeToolMaterial))
            .setIconCoord(4, 0)
            .setItemName("blazepickaxe");
    blazeAxe =
        (new BlazeItemAxe(DefaultProps.BLAZE_AXE_ID, blazeToolMaterial))
            .setIconCoord(5, 0)
            .setItemName("blazeaxe");
    blazeHoe =
        (new BlazeItemHoe(DefaultProps.BLAZE_HOE_ID, blazeToolMaterial))
            .setIconCoord(6, 0)
            .setItemName("blazehoe");

    LanguageRegistry.addName(blazeSword, DefaultNames.EN.BLAZE_SWORD);
    LanguageRegistry.instance().addNameForObject(blazeSword, "ja_JP", DefaultNames.JP.BLAZE_SWORD);
    LanguageRegistry.addName(blazeShovel, DefaultNames.EN.BLAZE_SHOVEL);
    LanguageRegistry.instance()
        .addNameForObject(blazeShovel, "ja_JP", DefaultNames.JP.BLAZE_SHOVEL);
    LanguageRegistry.addName(blazePickaxe, DefaultNames.EN.BLAZE_PICKAXE);
    LanguageRegistry.instance()
        .addNameForObject(blazePickaxe, "ja_JP", DefaultNames.JP.BLAZE_PICKAXE);
    LanguageRegistry.addName(blazeAxe, DefaultNames.EN.BLAZE_AXE);
    LanguageRegistry.instance().addNameForObject(blazeAxe, "ja_JP", DefaultNames.JP.BLAZE_AXE);
    LanguageRegistry.addName(blazeHoe, DefaultNames.EN.BLAZE_HOE);
    LanguageRegistry.instance().addNameForObject(blazeHoe, "ja_JP", DefaultNames.JP.BLAZE_HOE);

    GameRegistry.addRecipe(
        new ItemStack(blazeSword, 1),
        new Object[] {
          "X", "X", "S", Character.valueOf('X'), BlazeIngot, Character.valueOf('S'), Item.blazeRod
        });
    GameRegistry.addRecipe(
        new ItemStack(blazeHoe, 1),
        new Object[] {
          "XX",
          " S",
          " S",
          Character.valueOf('X'),
          BlazeIngot,
          Character.valueOf('S'),
          Item.blazeRod
        });
    GameRegistry.addRecipe(
        new ItemStack(blazeShovel, 1),
        new Object[] {
          "X", "S", "S", Character.valueOf('X'), BlazeIngot, Character.valueOf('S'), Item.blazeRod
        });
    GameRegistry.addRecipe(
        new ItemStack(blazePickaxe, 1),
        new Object[] {
          "XXX",
          " S ",
          " S ",
          Character.valueOf('X'),
          BlazeIngot,
          Character.valueOf('S'),
          Item.blazeRod
        });

    GameRegistry.addRecipe(
        new ItemStack(blazeAxe, 1),
        new Object[] {
          "XX",
          "XS",
          " S",
          Character.valueOf('X'),
          BlazeIngot,
          Character.valueOf('S'),
          Item.blazeRod
        });

    BlazeShears =
        (new BlazeItemShears(DefaultProps.BLAZE_SHEARS_ID))
            .setIconCoord(1, 1)
            .setItemName("blazeShears");
    LanguageRegistry.addName(BlazeShears, DefaultNames.EN.BLAZE_SHEARS);
    LanguageRegistry.instance()
        .addNameForObject(BlazeShears, "ja_JP", DefaultNames.JP.BLAZE_SHEARS);
    GameRegistry.addRecipe(
        new ItemStack(BlazeShears, 1),
        new Object[] {
          " X", "X ", Character.valueOf('X'), BlazeIngot,
        });

    FlintAndBlazeIngot =
        (new FlintAndBlazeIngotItemFlintAndSteel(DefaultProps.FLINT_AND_BLAZE_INGOT_ID))
            .setIconCoord(15, 0)
            .setItemName("flintAndBlazeIngot");
    LanguageRegistry.addName(FlintAndBlazeIngot, DefaultNames.EN.FLINT_AND_BLAZE_INGOT);
    LanguageRegistry.instance()
        .addNameForObject(FlintAndBlazeIngot, "ja_JP", DefaultNames.JP.FLINT_AND_BLAZE_INGOT);
    GameRegistry.addRecipe(
        new ItemStack(FlintAndBlazeIngot, 1),
        new Object[] {
          "S ", " X", Character.valueOf('S'), BlazeIngot, Character.valueOf('X'), Item.flint
        });

    BlazeBow =
        (new BlazeItemBow(DefaultProps.BLAZE_BOW_ID, 768))
            .setIconCoord(11, 0)
            .setItemName("blazeBow");
    LanguageRegistry.addName(BlazeBow, DefaultNames.EN.BLAZE_BOW);
    LanguageRegistry.instance().addNameForObject(BlazeBow, "ja_JP", DefaultNames.JP.BLAZE_BOW);
    GameRegistry.addRecipe(
        new ItemStack(BlazeBow, 1),
        new Object[] {
          "SX ",
          "S X",
          "SX ",
          Character.valueOf('X'),
          Item.blazeRod,
          Character.valueOf('S'),
          Item.silk
        });
  }
コード例 #8
0
ファイル: GCJupiterItems.java プロジェクト: sawid/4-Space
public class GCJupiterItems {
  public static Item jupiterItemBasic;
  public static Item spaceshipT5;
  //    public static Item schematic;

  public static Item clearDiamondPickaxe;
  public static Item clearDiamondAxe;
  public static Item clearDiamondHoe;
  public static Item clearDiamondSpade;
  public static Item clearDiamondSword;
  public static Item clearDiamondHelmet;
  public static Item clearDiamondChestplate;
  public static Item clearDiamondLeggings;
  public static Item clearDiamondBoots;

  public static EnumArmorMaterial ARMORCLEARDIAMOND =
      EnumHelper.addArmorMaterial("ClearDiamond", 42, new int[] {4, 9, 7, 4}, 12);
  public static EnumToolMaterial TOOLCLEARDIAMOND =
      EnumHelper.addToolMaterial("ClearDiamond", 3, 1024, 5.0F, 2.5F, 8);

  public static void initItems() {
    GCJupiterItems.jupiterItemBasic =
        new GCJupiterItem(GCJupiterConfigManager.idItemJupiterBasic)
            .setUnlocalizedName("jupiterBasic");
    GCJupiterItems.spaceshipT5 =
        new SCCoreItemSpaceshipTier5(GCJupiterConfigManager.idItemSpaceshipTier5)
            .setUnlocalizedName("spaceshipTier5");
    //        SCCoreItems.schematic = new
    // SCCoreItemSchematic(SCCoreConfigManager.idItemSchematicMars).setUnlocalizedName("schematic");

    GCJupiterItems.clearDiamondPickaxe =
        new SCCoreItemClearDiamondPickaxe(
                GCJupiterConfigManager.idToolClearDiamondPickaxe, GCJupiterItems.TOOLCLEARDIAMOND)
            .setUnlocalizedName("ClearDiamondPick");
    GCJupiterItems.clearDiamondAxe =
        new SCCoreItemClearDiamondAxe(
                GCJupiterConfigManager.idToolClearDiamondAxe, GCJupiterItems.TOOLCLEARDIAMOND)
            .setUnlocalizedName("ClearDiamondAxe");
    GCJupiterItems.clearDiamondHoe =
        new SCCoreItemClearDiamondHoe(
                GCJupiterConfigManager.idToolClearDiamondHoe, GCJupiterItems.TOOLCLEARDIAMOND)
            .setUnlocalizedName("ClearDiamondHoe");
    GCJupiterItems.clearDiamondSpade =
        new SCCoreItemClearDiamondSpade(
                GCJupiterConfigManager.idToolClearDiamondSpade, GCJupiterItems.TOOLCLEARDIAMOND)
            .setUnlocalizedName("ClearDiamondSpade");
    GCJupiterItems.clearDiamondSword =
        new SCCoreItemClearDiamondSword(
                GCJupiterConfigManager.idToolClearDiamondSword, GCJupiterItems.TOOLCLEARDIAMOND)
            .setUnlocalizedName("ClearDiamondSword");

    GCJupiterItems.clearDiamondHelmet =
        new SCCoreItemClearDiamondArmor(
                GCJupiterConfigManager.idArmorClearDiamondHelmet,
                GCJupiterItems.ARMORCLEARDIAMOND,
                7,
                0,
                false)
            .setUnlocalizedName("ClearDiamondHelmet");
    GCJupiterItems.clearDiamondChestplate =
        new SCCoreItemClearDiamondArmor(
                GCJupiterConfigManager.idArmorClearDiamondChestplate,
                GCJupiterItems.ARMORCLEARDIAMOND,
                7,
                1,
                false)
            .setUnlocalizedName("ClearDiamondChestplate");
    GCJupiterItems.clearDiamondLeggings =
        new SCCoreItemClearDiamondArmor(
                GCJupiterConfigManager.idArmorClearDiamondLeggings,
                GCJupiterItems.ARMORCLEARDIAMOND,
                7,
                2,
                false)
            .setUnlocalizedName("ClearDiamondLeggings");
    GCJupiterItems.clearDiamondBoots =
        new SCCoreItemClearDiamondArmor(
                GCJupiterConfigManager.idArmorClearDiamondBoots,
                GCJupiterItems.ARMORCLEARDIAMOND,
                7,
                3,
                false)
            .setUnlocalizedName("ClearDiamondBoots");
  }

  public static void registerHarvestLevels() {}
}
コード例 #9
0
  @Override
  public void init() {
    GameRegistry.registerWorldGenerator(GenerationManager.instance);

    itemWoolGin = new ItemWoolGin(Configurator.item_woolginID.getInt());
    itemBackpack = new ItemBackpack(Configurator.item_backpackID.getInt());

    blockOres = new BlockOre(Configurator.block_oresID.getInt());
    GameRegistry.registerBlock(blockOres, ItemBlockOre.class, "projectred.exploration.ore");
    for (EnumOre o : EnumOre.VALID_ORES) {
      MinecraftForge.setBlockHarvestLevel(blockOres, "pickaxe", o.harvesLevel);
    }

    blockStones = new BlockSpecialStone(Configurator.block_stonesID.getInt());
    GameRegistry.registerBlock(
        blockStones, ItemBlockSpecialStone.class, "projectred.exploration.stone");

    if (Configurator.gen_SpreadingMoss.getBoolean(true)) {
      int mc = Block.cobblestoneMossy.blockID;
      Block.blocksList[mc] = null;
      new BlockPhotosyntheticCobblestone(mc);

      int sb = Block.stoneBrick.blockID;
      Block.blocksList[sb] = null;
      new BlockPhotosyntheticStoneBrick(sb);
    }

    toolMaterialRuby = EnumHelper.addToolMaterial("RUBY", 2, 500, 8.0F, 4, 12);
    toolMaterialSapphire = EnumHelper.addToolMaterial("SAPPHIRE", 2, 500, 8.0F, 3, 16);
    toolMaterialPeridot = EnumHelper.addToolMaterial("PERIDOT", 2, 500, 8.75F, 3.25F, 12);

    itemRubyAxe = new ItemGemAxe(Configurator.item_rubyAxe.getInt(), EnumSpecialTool.RUBYAXE);
    itemSapphireAxe =
        new ItemGemAxe(Configurator.item_sapphireAxe.getInt(), EnumSpecialTool.SAPPHIREAXE);
    itemPeridotAxe =
        new ItemGemAxe(Configurator.item_peridotAxe.getInt(), EnumSpecialTool.PERIDOTAXE);
    MinecraftForge.setToolClass(itemRubyAxe, "axe", 2);
    MinecraftForge.setToolClass(itemSapphireAxe, "axe", 2);
    MinecraftForge.setToolClass(itemPeridotAxe, "axe", 2);

    itemRubyHoe = new ItemGemHoe(Configurator.item_rubyHoe.getInt(), EnumSpecialTool.RUBYHOE);
    itemSapphireHoe =
        new ItemGemHoe(Configurator.item_sapphireHoe.getInt(), EnumSpecialTool.SAPPHIREHOE);
    itemPeridotHoe =
        new ItemGemHoe(Configurator.item_peridotHoe.getInt(), EnumSpecialTool.PERIDOTHOE);
    MinecraftForge.setToolClass(itemRubyHoe, "hoe", 2);
    MinecraftForge.setToolClass(itemSapphireHoe, "hoe", 2);
    MinecraftForge.setToolClass(itemPeridotHoe, "hoe", 2);

    itemRubyPickaxe =
        new ItemGemPickaxe(Configurator.item_rubyPickaxe.getInt(), EnumSpecialTool.RUBYPICKAXE);
    itemSapphirePickaxe =
        new ItemGemPickaxe(
            Configurator.item_sapphirePickaxe.getInt(), EnumSpecialTool.SAPPHIREPICKAXE);
    itemPeridotPickaxe =
        new ItemGemPickaxe(
            Configurator.item_peridotPickaxe.getInt(), EnumSpecialTool.PERIDOTPICKAXE);
    MinecraftForge.setToolClass(itemRubyPickaxe, "pickaxe", 2);
    MinecraftForge.setToolClass(itemSapphirePickaxe, "pickaxe", 2);
    MinecraftForge.setToolClass(itemPeridotPickaxe, "pickaxe", 2);

    itemRubyShovel =
        new ItemGemShovel(Configurator.item_rubyShovel.getInt(), EnumSpecialTool.RUBYSHOVEL);
    itemSapphireShovel =
        new ItemGemShovel(
            Configurator.item_sapphireShovel.getInt(), EnumSpecialTool.SAPPHIRESHOVEL);
    itemPeridotShovel =
        new ItemGemShovel(Configurator.item_peridotShovel.getInt(), EnumSpecialTool.PERIDOTSHOVEL);
    MinecraftForge.setToolClass(itemRubyShovel, "shovel", 2);
    MinecraftForge.setToolClass(itemSapphireShovel, "shovel", 2);
    MinecraftForge.setToolClass(itemPeridotShovel, "shovel", 2);

    itemRubySword =
        new ItemGemSword(Configurator.item_rubySword.getInt(), EnumSpecialTool.RUBYSWORD);
    itemSapphireSword =
        new ItemGemSword(Configurator.item_sapphireSword.getInt(), EnumSpecialTool.SAPPHIRESWORD);
    itemPeridotSword =
        new ItemGemSword(Configurator.item_peridotSword.getInt(), EnumSpecialTool.PERIDOTSWORD);
    MinecraftForge.setToolClass(itemRubySword, "sword", 2);
    MinecraftForge.setToolClass(itemSapphireSword, "sword", 2);
    MinecraftForge.setToolClass(itemPeridotSword, "sword", 2);

    itemWoodSaw = new ItemGemSaw(Configurator.item_woodSaw.getInt(), EnumSpecialTool.WOODSAW);
    itemStoneSaw = new ItemGemSaw(Configurator.item_stoneSaw.getInt(), EnumSpecialTool.STONESAW);
    itemIronSaw = new ItemGemSaw(Configurator.item_ironSaw.getInt(), EnumSpecialTool.IRONSAW);
    itemGoldSaw = new ItemGemSaw(Configurator.item_goldSaw.getInt(), EnumSpecialTool.GOLDSAW);
    itemRubySaw = new ItemGemSaw(Configurator.item_rubySaw.getInt(), EnumSpecialTool.RUBYSAW);
    itemSapphireSaw =
        new ItemGemSaw(Configurator.item_sapphireSaw.getInt(), EnumSpecialTool.SAPPHIRESAW);
    itemPeridotSaw =
        new ItemGemSaw(Configurator.item_peridotSaw.getInt(), EnumSpecialTool.PERIDOTSAW);
    itemDiamondSaw =
        new ItemGemSaw(Configurator.item_diamondSaw.getInt(), EnumSpecialTool.DIAMONDSAW);

    itemWoodSickle =
        new ItemGemSickle(Configurator.item_woodSickle.getInt(), EnumSpecialTool.WOODSICKLE);
    itemStoneSickle =
        new ItemGemSickle(Configurator.item_stoneSickle.getInt(), EnumSpecialTool.STONESICKLE);
    itemIronSickle =
        new ItemGemSickle(Configurator.item_ironSickle.getInt(), EnumSpecialTool.IRONSICKLE);
    itemGoldSickle =
        new ItemGemSickle(Configurator.item_goldSickle.getInt(), EnumSpecialTool.GOLDSICKLE);
    itemRubySickle =
        new ItemGemSickle(Configurator.item_rubySickle.getInt(), EnumSpecialTool.RUBYSICKLE);
    itemSapphireSickle =
        new ItemGemSickle(
            Configurator.item_sapphireSickle.getInt(), EnumSpecialTool.SAPPHIRESICKLE);
    itemPeridotSickle =
        new ItemGemSickle(Configurator.item_peridotSickle.getInt(), EnumSpecialTool.PERIDOTSICKLE);
    itemDiamondSickle =
        new ItemGemSickle(Configurator.item_diamondSickle.getInt(), EnumSpecialTool.DIAMONDSICKLE);

    for (EnumSpecialStone s : EnumSpecialStone.VALID_STONE) {
      MicroMaterialRegistry.registerMaterial(
          new BlockMicroMaterial(ProjectRedExploration.blockStones, s.meta),
          ProjectRedExploration.blockStones.getUnlocalizedName()
              + (s.meta > 0 ? "_" + s.meta : ""));
    }
  }
コード例 #10
0
ファイル: Core.java プロジェクト: KodeKishin/ME-Craft
@Mod(modid = "KodeKishin", name = "ME-Craft", version = "a0.0.1")
@NetworkMod(
    clientSideRequired = true,
    serverSideRequired = false,
    channels = "ME-Craft",
    packetHandler = PacketManager.class)
public class Core {
  public static int ItemID = 2789;
  public static int BlockID = 901;
  public static int BiomeBlockID = 250;
  public static int BiomeID = 23;
  public static int AchievementID = 2001;
  public static int x1 = 901 + 34;
  public static int x2 = 901 + 35;
  public static boolean INITIALIZED = false;

  @Mod.PreInit
  public static void preInit(FMLPreInitializationEvent event) {
    // Config(Ayarlar)
    Configuration config = new Configuration(event.getSuggestedConfigurationFile());
    config.load();
    ItemID = config.get("Item:", "Base Item ID", 2789).getInt();
    BlockID = config.get("Block:", "Base Block ID", 901).getInt();
    x1 = config.get("Block:", "Pressure Machine Idle ID", 901 + 34).getInt();
    x2 = config.get("Block:", "Pressure Machine Runing ID", 901 + 35).getInt();
    BiomeBlockID = config.get("Biome:", "Biome Block ID", 250).getInt();
    BiomeID = config.get("Biome:", "Biome ID", 23).getInt();
    AchievementID = config.get("Achievement:", "Base Achievement ID", 2001).getInt();
    config.save();
  }

  public static void init() {

    if (!INITIALIZED) {
      System.out.println("ME-Craft Loaded:");
      INITIALIZED = true;
    }
  }

  public static final String modid = "KodeKishin";
  public static String CHANNEL = "ME-Craft";

  public static final ArrayList bcDependants = new ArrayList();

  int x = Color.black.getRed() << 16 + (Color.white.getGreen() << 8);
  int y = Color.white.getRed() << 16 + (Color.white.getGreen() << 8);

  public static CreativeTabs MEC =
      new CreativeTabs("MEC") {
        public ItemStack getIconItemStack() {
          return new ItemStack(Core.Heart, 1, 0);
        }
      };

  @Instance(Core.modid)
  public static Core instance = new Core();

  private GuiHandler guihandler = new GuiHandler();
  public MECBucketHandler dirtBucket;
  public static Item MECBucket;
  public static Item Batery;
  public static Item IBatery;
  public static Item Heart =
      new Heart(ItemID, 10, 12, true)
          .setMaxStackSize(64)
          .setCreativeTab(MEC)
          .setUnlocalizedName("heart");
  public static Item GHeart =
      new GHeart(ItemID + 1, -10, 12, true)
          .setMaxStackSize(64)
          .setCreativeTab(MEC)
          .setUnlocalizedName("gheart");
  public static Item MECWrench;
  public static Item IronPlate;
  public static Item GoldPlate;
  public static Item CopperPlate;
  public static Item SteelPlate;
  public static Item CopperIngot;
  public static Item SteelIngot;
  public static ItemArmor CPHelmet;
  public static ItemArmor CPChestPlate;
  public static ItemArmor CPChestPlateWW;
  public static ItemArmor CPLeggings;
  public static ItemArmor CPBoots;
  public static Item CPSword;
  public static Item CSoulPart;
  public static Item PSoulPart;
  public static Item CWSoulPart;
  public static Item ESoulPart;
  public static Item ZSoulPart;
  public static Item CRSoulPart;
  public static Item SSoulPart;
  public static Item HSoulPart;
  public static Material MaterialMECLiquid = (new MaterialMECLiquid(MapColor.iceColor)).water;
  public static Material MaterialMEC = (new MaterialMEC(MapColor.iceColor).rock);
  public static final Block Deneme = new Deneme((x1), false).setHardness(1.5F).setCreativeTab(MEC);
  public static final Block CPSnad =
      new CPSand(BiomeBlockID).setHardness(0.1F).setCreativeTab(MEC).setUnlocalizedName("cpsand");
  public static final Block CopperOre =
      new CopperOre(BlockID + 37)
          .setHardness(1.5F)
          .setCreativeTab(MEC)
          .setUnlocalizedName("copperOre");

  public static final Block CopperCable =
      new CopperCable(BlockID + 40).setCreativeTab(MEC).setUnlocalizedName("copperWire2");
  public static final Block DenemeB = new Deneme((x2), true).setHardness(1.5F);
  public static final BlockBasicMachine blockMachine = new BlockBasicMachine(BlockID + 36);
  public static final BlockSolarGenerator blocksolar = new BlockSolarGenerator(BlockID + 42);
  public static final BlockBatteryBox blockbat = new BlockBatteryBox(BlockID + 43);
  public static final Block MECLiquid =
      new MECLiquid(BlockID + 38, MaterialMECLiquid).setHardness(100.0F);
  public static final Block MECLiquidStill =
      (new MECLiquidStill(BlockID + 39, MaterialMECLiquid)).setHardness(100.0F);
  public static final Block MermerB =
      (new SMermer(BlockID + 33))
          .setHardness(1.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mermerb")
          .setCreativeTab(MEC);
  public static final Block Mermer =
      (new Mermer(BlockID))
          .setHardness(1.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mermer")
          .setCreativeTab(MEC);
  public static final Block SMermer =
      (new SMermer(BlockID + 2))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("sermer")
          .setCreativeTab(MEC);
  public static final Block AMermer =
      (new SMermer(BlockID + 3))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("acik mavi mermer")
          .setCreativeTab(MEC);
  public static final Block BMermer =
      (new SMermer(BlockID + 4))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("acik gri mermer")
          .setCreativeTab(MEC);
  public static final Block CMermer =
      (new SMermer(BlockID + 5))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("acik yesil mermer")
          .setCreativeTab(MEC);
  public static final Block DMermer =
      (new SMermer(BlockID + 6))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("eflatun mermer")
          .setCreativeTab(MEC);
  public static final Block EMermer =
      (new SMermer(BlockID + 7))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("gri mermer")
          .setCreativeTab(MEC);
  public static final Block FMermer =
      (new SMermer(BlockID + 8))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("kahve rengi mermer")
          .setCreativeTab(MEC);
  public static final Block GMermer =
      (new SMermer(BlockID + 9))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("kirmizi mermer")
          .setCreativeTab(MEC);
  public static final Block HMermer =
      (new SMermer(BlockID + 10))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mavi mermer")
          .setCreativeTab(MEC);
  public static final Block IMermer =
      (new SMermer(BlockID + 11))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mor mermer")
          .setCreativeTab(MEC);
  public static final Block JMermer =
      (new SMermer(BlockID + 12))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("pembe mermer")
          .setCreativeTab(MEC);
  public static final Block KMermer =
      (new SMermer(BlockID + 13))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("sari mermer")
          .setCreativeTab(MEC);
  public static final Block LMermer =
      (new SMermer(BlockID + 14))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("siyah mermer")
          .setCreativeTab(MEC);
  public static final Block MMermer =
      (new SMermer(BlockID + 15))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("turkuaz mermer")
          .setCreativeTab(MEC);
  public static final Block NMermer =
      (new SMermer(BlockID + 16))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("turuncu mermer")
          .setCreativeTab(MEC);
  public static final Block OMermer =
      (new SMermer(BlockID + 17))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("yesil  mermer")
          .setCreativeTab(MEC);
  public static final Block AMermerB =
      (new SMermer(BlockID + 18))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("acik mavi tugla")
          .setCreativeTab(MEC);
  public static final Block BMermerB =
      (new SMermer(BlockID + 19))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("acik gri tugla")
          .setCreativeTab(MEC);
  public static final Block CMermerB =
      (new SMermer(BlockID + 20))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("koyu yesil tugla")
          .setCreativeTab(MEC);
  public static final Block DMermerB =
      (new SMermer(BlockID + 21))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("eflatun tugla")
          .setCreativeTab(MEC);
  public static final Block EMermerB =
      (new SMermer(BlockID + 22))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("gri tugla")
          .setCreativeTab(MEC);
  public static final Block FMermerB =
      (new SMermer(BlockID + 23))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("kahverengi tugla")
          .setCreativeTab(MEC);
  public static final Block GMermerB =
      (new SMermer(BlockID + 24))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("kirmizi tugla")
          .setCreativeTab(MEC);
  public static final Block HMermerB =
      (new SMermer(BlockID + 25))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mavi tugla")
          .setCreativeTab(MEC);
  public static final Block IMermerB =
      (new SMermer(BlockID + 26))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("mor tugla")
          .setCreativeTab(MEC);
  public static final Block JMermerB =
      (new SMermer(BlockID + 27))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("pembe tugla")
          .setCreativeTab(MEC);
  public static final Block KMermerB =
      (new SMermer(BlockID + 28))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("sari tugla")
          .setCreativeTab(MEC);
  public static final Block LMermerB =
      (new SMermer(BlockID + 29))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("siyah tugla")
          .setCreativeTab(MEC);
  public static final Block MMermerB =
      (new SMermer(BlockID + 30))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("turkuaz tugla")
          .setCreativeTab(MEC);
  public static final Block NMermerB =
      (new SMermer(BlockID + 31))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("turuncu tugla")
          .setCreativeTab(MEC);
  public static final Block OMermerB =
      (new SMermer(BlockID + 32))
          .setHardness(3.5F)
          .setResistance(10.0F)
          .setUnlocalizedName("yesil tugla")
          .setCreativeTab(MEC);
  public static final Block KirikMermer =
      (new KMermer(BlockID + 1))
          .setHardness(2.0F)
          .setResistance(10.0F)
          .setUnlocalizedName("kermer")
          .setCreativeTab(MEC);
  public static MECWorldGenerator worldGen = new MECWorldGenerator();
  public static MECWorldGenerator2 worldGenCopper = new MECWorldGenerator2();
  public static MECWorldGenerator3 worldGenML = new MECWorldGenerator3();
  public static WorldGenFuelLakes worldGen3 = new WorldGenFuelLakes(MECLiquid.blockID);
  public static WorldGenLiquids worldGen2 = new WorldGenLiquids(MECLiquid.blockID);
  public static final BiomeGenBase MarbleBiome =
      (new BiomeGenMarble(BiomeID)).setBiomeName("The Corruption");
  public static final int dimension = 9;
  public static final int MECGUiID = 0;
  public static final Achievement timeAchieve =
      new Achievement(AchievementID, "Marble", 1, -2, KirikMermer, null)
          .registerAchievement()
          .setSpecial();
  public static final Achievement timeAchieve3 =
      new Achievement(AchievementID + 3, "Pressure", 1, -5, Deneme, timeAchieve)
          .registerAchievement()
          .setSpecial();
  public static final Achievement timeAchieve2 =
      new Achievement(AchievementID + 1, "Marble2", -4, -5, Mermer, timeAchieve3)
          .registerAchievement()
          .setSpecial();
  public static final Achievement timh =
      new Achievement(AchievementID + 5, "Heart", -4, 0, Heart, timeAchieve)
          .registerAchievement()
          .setSpecial();
  public static final Achievement timg =
      new Achievement(AchievementID + 4, "GHeart", 4, 0, GHeart, timeAchieve)
          .registerAchievement()
          .setSpecial();
  public static final Achievement cc =
      new Achievement(AchievementID + 2, "Copper", 4, -2, CopperOre, null)
          .registerAchievement()
          .setSpecial();
  public static AchievementPage page1 =
      new AchievementPage("ME-Craft", timeAchieve, timeAchieve3, timeAchieve2, cc, timh, timg);
  public static EnumToolMaterial CP = EnumHelper.addToolMaterial("cp", 5, 20000, 20.0f, 5, 30);
  public static EnumArmorMaterial CPA =
      EnumHelper.addArmorMaterial("cp", 50, new int[] {6, 16, 12, 6}, 30);

  @SidedProxy(clientSide = "KodeKishin.ClientProxy", serverSide = "KodeKishin.CommonProxy")
  public static CommonProxy proxy;

  @Init
  public void load(FMLInitializationEvent event) {
    proxy.registerRenderers();
  }

  @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);
  }

  private void addAchievementName(String ach, String name) {
    LanguageRegistry.instance().addStringLocalization("achievement." + ach, "en_US", name);
  }

  private void addAchievementDesc(String ach, String desc) {
    LanguageRegistry.instance()
        .addStringLocalization("achievement." + ach + ".desc", "en_US", desc);
  }

  public void addAchievementLocalizations() {
    this.addAchievementName("Marble", "Start the Mod");
    this.addAchievementDesc("Marble", "You are starting the Mod");
    this.addAchievementName("Marble2", "Get The Marble");
    this.addAchievementDesc("Marble2", "You are Learning Something!");
    this.addAchievementName("Copper", "Find Copper");
    this.addAchievementDesc("Copper", "You found a new Ore");
    this.addAchievementName("Pressure", "Make A Pressure Machine");
    this.addAchievementDesc("Pressure", "You can make awesome things!");
    this.addAchievementName("Heart", "Friend Killer");
    this.addAchievementDesc("Heart", "You killed a Friend Mip");
    this.addAchievementName("GHeart", "Enemy Killer");
    this.addAchievementDesc("GHeart", "You killed a Enemy Banion");
  }

  public void ArmorHUD() {}

  public static Object getFirstDependant() {
    if (bcDependants.size() > 0) {
      return bcDependants.get(0);
    }

    return null;
  }
}
コード例 #11
0
ファイル: WarpCraft.java プロジェクト: jedk1/warpcraft
@Mod(modid = "WarpCraft", name = "WarpCraft", version = "Version 2.0 [MC 1.4.2]")
@NetworkMod(
    channels = {"WarpCraft"},
    clientSideRequired = true,
    serverSideRequired = false,
    packetHandler = PacketHandler.class)
public class WarpCraft {

  @Instance("WarpCraft")
  public static WarpCraft instance;

  @SidedProxy(
      clientSide = "warpcraft.client.handlers.ClientProxy",
      serverSide = "warpcraft.common.handlers.CommonProxy")
  public static CommonProxy proxy;

  // Dimension

  // Blocks

  public static EventSounds soundHandler = new EventSounds();
  public static GuiHandler guiHandler = new GuiHandler();
  public static ItemHandler itemHandler = new ItemHandler(null);

  public static WorldProviderWarp WarpProvider = new WorldProviderWarp();

  static EnumToolMaterial EnumToolMaterialWARP1 =
      EnumHelper.addToolMaterial("WARP1", 7, 2500, 30.0F, 10, 25);
  static EnumToolMaterial EnumToolMaterialWARP =
      EnumHelper.addToolMaterial("WARP2", 3, 4000, 8.0F, 25, 10);

  static EnumArmorMaterial EnumArmorMaterialCRYSTALITE =
      EnumHelper.addArmorMaterial("CRYSTALITE", 35, new int[] {4, 9, 7, 6}, 15);

  public static CreativeTabs warpTabBlocks = new WarpTabBlocks("warpTabBlocks");
  public static CreativeTabs warpTabItems = new WarpTabItems("warpTabItems");

  // Config Values
  // DIM
  public static int DIM;
  public static int BIOME;
  public static int SKY_COLOUR;

  public static int VSSuit1;
  public static int VSSuit2;

  // Achievements
  public static int Achievement1;
  public static int Achievement2;
  public static int Achievement3;

  private Object worldObj;

  private static final int WorldProviderWarp = DIM;

  @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);
  }

  @Init
  public void init(FMLInitializationEvent evt) {
    WCLanguage.init(evt);

    GameRegistry.registerTileEntity(TileEntityWarpInfuser.class, "Infuser");

    // Ore Generation
    GameRegistry.registerWorldGenerator(new WorldGeneratorWarpCraft());

    // Register Rendering Information
    proxy.registerRenderInformation();
    proxy.registerEntityInformation();
    // Register Dimension

    EntityRegistry.addSpawn(
        EntityRat.class, 5, 2, 3, EnumCreatureType.monster, WCBiomeGenBase.warp);
    EntityRegistry.addSpawn(
        EntitySquig.class, 2, 1, 2, EnumCreatureType.monster, WCBiomeGenBase.warp);
    // stuff

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

  @PostInit
  public void postInit(FMLPostInitializationEvent evt) {
    // TODO: Add Post-Initialization code such as mod hooks
  }
}