API tools faq
paste
Hafis_CZ

mar21´s m2cAPI

Hafis_CZ
Jun 25th, 2013
75
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 30.42 KB | None | 0 0
raw download clone embed print report
  1. // IMPORTS :
  2. import mar21.omega.ModCore;
  3. import net.minecraft.block.Block;
  4. import net.minecraft.creativetab.CreativeTabs;
  5. import net.minecraft.item.Item;
  6. import net.minecraft.item.ItemStack;
  7. import net.minecraft.item.crafting.FurnaceRecipes;
  8. import cpw.mods.fml.common.registry.GameRegistry;
  9. import cpw.mods.fml.common.registry.LanguageRegistry;
  10.  
  11. // CLASS :
  12. {
  13.     /**
  14.     Minecraft modding m2cAPI created by mar21
  15.     Easy way to make your code short and compact
  16.     You can use this m2cAPI if you have in mod description:
  17.        This mod is using the m2cAPI by mar21
  18.     Else give a Karma or Thank You on MinecraftForge forum
  19.     to my mar21 account. It will boost me with expanding
  20.     the api code. Thanks very much
  21.     Every pack of functions is marked with comment!
  22.     If something doesnt work send me a pm on MCForge forum!
  23.     **/
  24.    
  25.     // Block LanguageRegistry and GameRegistry //TODO
  26.     public static void regBlock(Block par1Block, String par2String)
  27.     {
  28.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  29.         LanguageRegistry.addName(par1Block, par2String);
  30.     }
  31.     public static void regBlock(Block[] par1BlockArray, String[] par2StringArray)
  32.     {
  33.         if (par1BlockArray.length == par2StringArray.length)
  34.         {
  35.             for (int i = 0; i < par1BlockArray.length; i++)
  36.             {
  37.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  38.                 LanguageRegistry.addName(par1BlockArray[i], par2StringArray[i]);
  39.             }
  40.         }
  41.     }
  42.     // Item LanguageRegistry //TODO
  43.     public static void regItem(Item par1Item, String par2String)
  44.     {
  45.         LanguageRegistry.addName(par1Item, par2String);
  46.     }
  47.     public static void regItem(Item[] par1ItemArray, String[] par2StringArray)
  48.     {
  49.         if (par1ItemArray.length == par2StringArray.length);
  50.         {
  51.             for (int i = 0; i < par1ItemArray.length; i++)
  52.             {
  53.                 LanguageRegistry.addName(par1ItemArray[i], par2StringArray[i]);
  54.             }
  55.         }
  56.     }
  57.     // Item and Block FurnaceRecipes.addSmelting() //TODO
  58.     public static void regSmelting(Item par1Item, Item par2Item, Float par3Float)
  59.     {
  60.         FurnaceRecipes.smelting().addSmelting(par1Item.itemID, new ItemStack(par2Item), par3Float);
  61.     }
  62.     public static void regSmelting(Item par1Item, Block par2Block, Float par3Float)
  63.     {
  64.         FurnaceRecipes.smelting().addSmelting(par1Item.itemID, new ItemStack(par2Block), par3Float);
  65.     }
  66.     public static void regSmelting(Item[] par1ItemArray, Item[] par2ItemArray, Float[] par3FloatArray)
  67.     {
  68.         if (par1ItemArray.length == par2ItemArray.length);
  69.         {
  70.             for (int i = 0; i < par1ItemArray.length; i++)
  71.             {
  72.                 FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2ItemArray[i]), par3FloatArray[i]);
  73.             }
  74.         }
  75.     }
  76.     public static void regSmelting(Item[] par1ItemArray, Item[] par2ItemArray, Float par3Float)
  77.     {
  78.         if (par1ItemArray.length == par2ItemArray.length);
  79.         {
  80.             for (int i = 0; i < par1ItemArray.length; i++)
  81.             {
  82.                 FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2ItemArray[i]), par3Float);
  83.             }
  84.         }
  85.     }
  86.     public static void regSmelting(Item[] par1ItemArray, Block[] par2BlockArray, Float[] par3FloatArray)
  87.     {
  88.         if (par1ItemArray.length == par2BlockArray.length);
  89.         {
  90.             for (int i = 0; i < par1ItemArray.length; i++)
  91.             {
  92.                 FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2BlockArray[i]), par3FloatArray[i]);
  93.             }
  94.         }
  95.     }
  96.     public static void regSmelting(Item[] par1ItemArray, Block[] par2BlockArray, Float par3Float)
  97.     {
  98.         if (par1ItemArray.length == par2BlockArray.length);
  99.         {
  100.             for (int i = 0; i < par1ItemArray.length; i++)
  101.             {
  102.                 FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2BlockArray[i]), par3Float);
  103.             }
  104.         }
  105.     }
  106.     public static void regSmelting(Block par1Block, Item par2Item, Float par3Float)
  107.     {
  108.         FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par3Float);
  109.     }
  110.     public static void regSmelting(Block par1Block, Block par2Block, Float par3Float)
  111.     {
  112.         FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par3Float);
  113.     }
  114.     public static void regSmelting(Block[] par1BlockArray, Item[] par2ItemArray, Float[] par3FloatArray)
  115.     {
  116.         if (par1BlockArray.length == par2ItemArray.length)
  117.         {
  118.             for (int i = 0; i < par1BlockArray.length; i++)
  119.             {
  120.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par3FloatArray[i]);
  121.             }
  122.         }
  123.     }
  124.     public static void regSmelting(Block[] par1BlockArray, Item[] par2ItemArray, Float par3Float)
  125.     {
  126.         if (par1BlockArray.length == par2ItemArray.length)
  127.         {
  128.             for(int i = 0; i < par1BlockArray.length; i++)
  129.             {
  130.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par3Float);
  131.             }
  132.         }
  133.     }
  134.     public static void regSmelting(Block[] par1BlockArray, Block[] par2BlockArray, Float[] par3FloatArray)
  135.     {
  136.         if (par1BlockArray.length == par2BlockArray.length)
  137.         {
  138.             for (int i = 0; i < par1BlockArray.length; i++)
  139.             {
  140.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par3FloatArray[i]);
  141.             }
  142.         }
  143.     }
  144.     public static void regSmelting(Block[] par1BlockArray, Block[] par2BlockArray, Float par3Float)
  145.     {
  146.         if (par1BlockArray.length == par2BlockArray.length)
  147.         {
  148.             for (int i = 0; i < par1BlockArray.length; i++)
  149.             {
  150.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par3Float);
  151.             }
  152.         }
  153.     }
  154.     // Ore LanguageRegistry,GameRegistry and smelting recipe into item or block //TODO
  155.     public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float)
  156.     {
  157.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  158.         LanguageRegistry.addName(par1Block, par3String);
  159.         FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float);
  160.     }
  161.     public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float)
  162.     {
  163.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  164.         LanguageRegistry.addName(par1Block, par3String);
  165.         FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);
  166.     }
  167.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray)
  168.     {
  169.         if (par1BlockArray.length == par2BlockArray.length)
  170.         {
  171.             for (int i = 0; i < par1BlockArray.length; i++)
  172.             {
  173.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  174.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  175.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);
  176.             }
  177.         }
  178.     }
  179.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float)
  180.     {
  181.         if (par1BlockArray.length == par2BlockArray.length)
  182.         {
  183.             for (int i = 0; i < par1BlockArray.length; i++)
  184.             {
  185.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  186.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  187.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);
  188.             }
  189.         }
  190.     }
  191.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray)
  192.     {
  193.         if (par1BlockArray.length == par2ItemArray.length)
  194.         {
  195.             for (int i = 0; i < par1BlockArray.length; i++)
  196.             {
  197.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  198.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  199.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);
  200.             }
  201.         }
  202.     }
  203.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float)
  204.     {
  205.         if (par1BlockArray.length == par2ItemArray.length)
  206.         {
  207.             for (int i = 0; i < par1BlockArray.length; i++)
  208.             {
  209.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  210.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  211.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);
  212.             }
  213.         }
  214.     }
  215.     // Ore LanguageRegistry,GameRegistry and toggleable smelting recipe into item or block - boolean //TODO
  216.     public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float, Boolean par5Boolean)
  217.     {
  218.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  219.         LanguageRegistry.addName(par1Block, par3String);
  220.         if(par5Boolean == true)
  221.         {
  222.             FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float); 
  223.         }
  224.     }
  225.     public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float, Boolean par5Boolean)
  226.     {
  227.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  228.         LanguageRegistry.addName(par1Block, par3String);
  229.         if(par5Boolean == true)
  230.         {
  231.             FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);
  232.         }
  233.     }
  234.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, Boolean par5Boolean)
  235.     {
  236.         if (par1BlockArray.length == par2BlockArray.length)
  237.         {
  238.             for (int i = 0; i < par1BlockArray.length; i++)
  239.             {
  240.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  241.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  242.                 if(par5Boolean == true)
  243.                 {
  244.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);
  245.                 }
  246.             }
  247.         }
  248.     }
  249.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, Boolean[] par5BooleanArray)
  250.     {
  251.         if (par1BlockArray.length == par2BlockArray.length)
  252.         {
  253.             for (int i = 0; i < par1BlockArray.length; i++)
  254.             {
  255.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  256.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  257.                 if(par5BooleanArray[i] == true)
  258.                 {
  259.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);
  260.                 }
  261.             }
  262.         }
  263.     }
  264.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, Boolean par5Boolean)
  265.     {
  266.         if (par1BlockArray.length == par2BlockArray.length)
  267.         {
  268.             for (int i = 0; i < par1BlockArray.length; i++)
  269.             {
  270.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  271.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  272.                 if(par5Boolean == true)
  273.                 {
  274.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);
  275.                 }
  276.             }
  277.         }
  278.     }
  279.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, Boolean[] par5BooleanArray)
  280.     {
  281.         if (par1BlockArray.length == par2BlockArray.length)
  282.         {
  283.             for (int i = 0; i < par1BlockArray.length; i++)
  284.             {
  285.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  286.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  287.                 if(par5BooleanArray[i] == true)
  288.                 {
  289.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);
  290.                 }
  291.             }
  292.         }
  293.     }
  294.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, Boolean par5Boolean)
  295.     {
  296.         if (par1BlockArray.length == par2ItemArray.length)
  297.         {
  298.             for (int i = 0; i < par1BlockArray.length; i++)
  299.             {
  300.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  301.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  302.                 if(par5Boolean == true)
  303.                 {
  304.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);
  305.                 }
  306.             }
  307.         }
  308.     }
  309.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, Boolean[] par5BooleanArray)
  310.     {
  311.         if (par1BlockArray.length == par2ItemArray.length)
  312.         {
  313.             for (int i = 0; i < par1BlockArray.length; i++)
  314.             {
  315.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  316.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  317.                 if(par5BooleanArray[i] == true)
  318.                 {
  319.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);
  320.                 }
  321.             }
  322.         }
  323.     }
  324.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, Boolean par5Boolean)
  325.     {
  326.         if (par1BlockArray.length == par2ItemArray.length)
  327.         {
  328.             for (int i = 0; i < par1BlockArray.length; i++)
  329.             {
  330.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  331.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  332.                 if(par5Boolean == true)
  333.                 {
  334.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);
  335.                 }
  336.             }
  337.         }
  338.     }
  339.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, Boolean[] par5BooleanArray)
  340.     {
  341.         if (par1BlockArray.length == par2ItemArray.length)
  342.         {
  343.             for (int i = 0; i < par1BlockArray.length; i++)
  344.             {
  345.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  346.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  347.                 if(par5BooleanArray[i] == true)
  348.                 {
  349.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);
  350.                 }
  351.             }
  352.         }
  353.     }
  354.     // Ore LanguageRegistry,GameRegistry and toggleable smelting recipe into item or block -integer //TODO
  355.     public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float, int par5Int)
  356.     {
  357.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  358.         LanguageRegistry.addName(par1Block, par3String);
  359.         if(par5Int == 1)
  360.         {
  361.             FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float); 
  362.         }
  363.     }
  364.     public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float, int par5Int)
  365.     {
  366.         GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());
  367.         LanguageRegistry.addName(par1Block, par3String);
  368.         if(par5Int == 1)
  369.         {
  370.             FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);
  371.         }
  372.     }
  373.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, int par5Int)
  374.     {
  375.         if (par1BlockArray.length == par2BlockArray.length)
  376.         {
  377.             for (int i = 0; i < par1BlockArray.length; i++)
  378.             {
  379.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  380.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  381.                 if(par5Int == 1)
  382.                 {
  383.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);
  384.                 }
  385.             }
  386.         }
  387.     }
  388.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, int[] par5IntArray)
  389.     {
  390.         if (par1BlockArray.length == par2BlockArray.length)
  391.         {
  392.             for (int i = 0; i < par1BlockArray.length; i++)
  393.             {
  394.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  395.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  396.                 if(par5IntArray[i] == 1)
  397.                 {
  398.                 FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);
  399.                 }
  400.             }
  401.         }
  402.     }
  403.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, int par5Int)
  404.     {
  405.         if (par1BlockArray.length == par2BlockArray.length)
  406.         {
  407.             for (int i = 0; i < par1BlockArray.length; i++)
  408.             {
  409.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  410.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  411.                 if(par5Int == 1)
  412.                 {
  413.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);
  414.                 }
  415.             }
  416.         }
  417.     }
  418.     public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, int[] par5IntArray)
  419.     {
  420.         if (par1BlockArray.length == par2BlockArray.length)
  421.         {
  422.             for (int i = 0; i < par1BlockArray.length; i++)
  423.             {
  424.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  425.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  426.                 if(par5IntArray[i] == 1)
  427.                 {
  428.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);
  429.                 }
  430.             }
  431.         }
  432.     }
  433.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, int par5Int)
  434.     {
  435.         if (par1BlockArray.length == par2ItemArray.length)
  436.         {
  437.             for (int i = 0; i < par1BlockArray.length; i++)
  438.             {
  439.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  440.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  441.                 if(par5Int == 1)
  442.                 {
  443.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);
  444.                 }
  445.             }
  446.         }
  447.     }
  448.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, int[] par5IntArray)
  449.     {
  450.         if (par1BlockArray.length == par2ItemArray.length)
  451.         {
  452.             for (int i = 0; i < par1BlockArray.length; i++)
  453.             {
  454.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  455.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  456.                 if(par5IntArray[i] == 1)
  457.                 {
  458.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);
  459.                 }
  460.             }
  461.         }
  462.     }
  463.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, int par5Int)
  464.     {
  465.         if (par1BlockArray.length == par2ItemArray.length)
  466.         {
  467.             for (int i = 0; i < par1BlockArray.length; i++)
  468.             {
  469.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  470.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  471.                 if(par5Int == 1)
  472.                 {
  473.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);
  474.                 }
  475.             }
  476.         }
  477.     }
  478.     public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, int[] par5IntArray)
  479.     {
  480.         if (par1BlockArray.length == par2ItemArray.length)
  481.         {
  482.             for (int i = 0; i < par1BlockArray.length; i++)
  483.             {
  484.                 GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());
  485.                 LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);
  486.                 if(par5IntArray[i] == 1)
  487.                 {
  488.                     FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);
  489.                 }
  490.             }
  491.         }
  492.     }
  493.     //TODO
  494.    
  495.     // Metadata LanguageRegistry //TODO
  496.     public static void regMeta(Block[] par1BlockArray,String[] par2StringArray)
  497.     {
  498.         if(par1BlockArray.length == par2StringArray.length)
  499.         {
  500.             for(int i = 0; i < par1BlockArray.length ; i++)
  501.             {
  502.                 LanguageRegistry.addName(new ItemStack(par1BlockArray[i], 1, i), par2StringArray[i]);
  503.             }
  504.         }
  505.     }
  506.     public static void regMeta(Item[] par1ItemArray,String[] par2StringArray)
  507.     {
  508.         if(par1ItemArray.length == par2StringArray.length)
  509.         {
  510.             for(int i = 0; i < par1ItemArray.length ; i++)
  511.             {
  512.                 LanguageRegistry.addName(new ItemStack(par1ItemArray[i], 1, i), par2StringArray[i]);
  513.             }
  514.         }
  515.     }
  516.     // Simple .setCreativeTab() //TODO
  517.     public static void regTab(Block par1Block, CreativeTabs par1CreativeTab)
  518.     {
  519.         par1Block.setCreativeTab(par1CreativeTab);
  520.     }
  521.     public static void regTab(Item par1Item, CreativeTabs par1CreativeTab)
  522.     {
  523.         par1Item.setCreativeTab(par1CreativeTab);
  524.     }
  525.     public static void regTab(Block[] par1BlockArray, CreativeTabs par1CreativeTab)
  526.     {
  527.         for (int i = 0; i < par1BlockArray.length; i++)
  528.         {
  529.             par1BlockArray[i].setCreativeTab(par1CreativeTab);
  530.         }
  531.     }
  532.     public static void regTab(Item[] par1ItemArray, CreativeTabs par1CreativeTab)
  533.     {
  534.         for (int i = 0; i < par1ItemArray.length; i++)
  535.         {
  536.             par1ItemArray[i].setCreativeTab(par1CreativeTab);
  537.         }
  538.     }
  539.     public static void regTab(Block[] par1BlockArray, CreativeTabs[] par1CreativeTabArray)
  540.     {
  541.         for (int i = 0; i < par1BlockArray.length; i++)
  542.         {
  543.             par1BlockArray[i].setCreativeTab(par1CreativeTabArray[i]);
  544.         }
  545.     }
  546.     public static void regTab(Item[] par1ItemArray, CreativeTabs[] par1CreativeTabArray)
  547.     {
  548.         for (int i = 0; i < par1ItemArray.length; i++)
  549.         {
  550.             par1ItemArray[i].setCreativeTab(par1CreativeTabArray[i]);
  551.         }
  552.     }
  553.     // Toggleable .setCreativeTab() - boolean //TODO
  554.     public static void regTab(Block par1Block, CreativeTabs par2Tab, Boolean par3Boolean)
  555.     {
  556.         if(par3Boolean == true)
  557.         {
  558.             par1Block.setCreativeTab(par2Tab);
  559.         }
  560.     }
  561.     public static void regTab(Item par1Item, CreativeTabs par2Tab, Boolean par3Boolean)
  562.     {
  563.         if(par3Boolean == true)
  564.         {
  565.             par1Item.setCreativeTab(par2Tab);
  566.         }
  567.     }
  568.     public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, Boolean par3Boolean)
  569.     {
  570.         for(int i = 0; i < par1ItemArray.length ; i++)
  571.             {
  572.             if(par3Boolean == true)
  573.                 {
  574.                 par1ItemArray[i].setCreativeTab(par2Tab);  
  575.                 }
  576.             }
  577.     }
  578.     public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, Boolean par3Boolean)
  579.     {
  580.         for(int i = 0; i < par1BlockArray.length ; i++)
  581.         {
  582.             if(par3Boolean == true)
  583.             {
  584.                 par1BlockArray[i].setCreativeTab(par2Tab);
  585.             }
  586.         }
  587.     }
  588.     public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, Boolean[] par3BooleanArray)
  589.     {
  590.         if(par1BlockArray.length == par3BooleanArray.length)
  591.         {
  592.             for(int i = 0; i < par1BlockArray.length;i++)
  593.             {
  594.                 if(par3BooleanArray[i] == true)
  595.                 {
  596.                     par1BlockArray[i].setCreativeTab(par2Tab);
  597.                 }
  598.             }
  599.         }
  600.     }
  601.     public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, Boolean[] par3BooleanArray)
  602.     {
  603.         if(par1ItemArray.length == par3BooleanArray.length)
  604.         {
  605.             for(int i = 0; i < par1ItemArray.length;i++)
  606.             {
  607.                 if(par3BooleanArray[i] == true)
  608.                 {
  609.                     par1ItemArray[i].setCreativeTab(par2Tab);
  610.                 }
  611.             }
  612.         }
  613.     }
  614.     public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, Boolean par3Boolean)
  615.     {
  616.         if(par1BlockArray.length == par2TabArray.length)
  617.         {
  618.             for(int i = 0; i < par1BlockArray.length;i++)
  619.             {
  620.                 if(par3Boolean == true)
  621.                 {
  622.                     par1BlockArray[i].setCreativeTab(par2TabArray[i]);
  623.                 }
  624.             }
  625.         }
  626.     }
  627.     public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, Boolean par3Boolean)
  628.     {
  629.         if(par1ItemArray.length == par2TabArray.length)
  630.         {
  631.             for(int i = 0; i < par1ItemArray.length;i++)
  632.             {
  633.                 if(par3Boolean == true)
  634.                 {
  635.                     par1ItemArray[i].setCreativeTab(par2TabArray[i]);
  636.                 }
  637.             }
  638.         }
  639.     }
  640.     public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, Boolean[] par3BooleanArray)
  641.     {
  642.         if(par1BlockArray.length == par2TabArray.length)
  643.         {
  644.             if(par1BlockArray.length == par3BooleanArray.length)
  645.             {
  646.                 for(int i = 0; i < par1BlockArray.length; i++)
  647.                 {
  648.                     if(par3BooleanArray[i] == true)
  649.                     {
  650.                         par1BlockArray[i].setCreativeTab(par2TabArray[i]);
  651.                     }
  652.                 }
  653.             }
  654.         }
  655.     }
  656.     // Toggleable .setCreativeTab() - integer //TODO
  657.     public static void regTab(Block par1Block, CreativeTabs par2Tab, int par3Int)
  658.     {
  659.         if(par3Int == 1)
  660.         {
  661.             par1Block.setCreativeTab(par2Tab);
  662.         }
  663.     }
  664.     public static void regTab(Item par1Item, CreativeTabs par2Tab, int par3Int)
  665.     {
  666.         if(par3Int == 1)
  667.         {
  668.             par1Item.setCreativeTab(par2Tab);
  669.         }
  670.     }
  671.     public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, int par3Int)
  672.     {
  673.         for(int i = 0; i < par1ItemArray.length ; i++)
  674.                 {
  675.                     if(par3Int == 1)
  676.                     {
  677.                         par1ItemArray[i].setCreativeTab(par2Tab);
  678.                     }
  679.                 }
  680.     }
  681.     public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, int par3Int)
  682.     {
  683.         for(int i = 0; i < par1BlockArray.length ; i++)
  684.         {
  685.             if(par3Int == 1)
  686.             {
  687.                 par1BlockArray[i].setCreativeTab(par2Tab);
  688.             }
  689.         }
  690.     }
  691.     public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, int[] par3IntArray)
  692.     {
  693.         if(par1BlockArray.length == par3IntArray.length)
  694.         {
  695.             for(int i = 0; i < par1BlockArray.length;i++)
  696.             {
  697.                 if(par3IntArray[i] == 1)
  698.                 {
  699.                     par1BlockArray[i].setCreativeTab(par2Tab);
  700.                 }
  701.             }
  702.         }
  703.     }
  704.     public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, int[] par3IntArray)
  705.     {
  706.         if(par1ItemArray.length == par3IntArray.length)
  707.         {
  708.             for(int i = 0; i < par1ItemArray.length;i++)
  709.             {
  710.                 if(par3IntArray[i] == 1)
  711.                 {
  712.                     par1ItemArray[i].setCreativeTab(par2Tab);
  713.                 }
  714.             }
  715.         }
  716.     }
  717.     public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, int par3Int)
  718.     {
  719.         if(par1BlockArray.length == par2TabArray.length)
  720.         {
  721.             for(int i = 0; i < par1BlockArray.length;i++)
  722.             {
  723.                 if(par3Int == 1)
  724.                 {
  725.                     par1BlockArray[i].setCreativeTab(par2TabArray[i]);
  726.                 }
  727.             }
  728.         }
  729.     }
  730.     public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, int par3Int)
  731.     {
  732.         if(par1ItemArray.length == par2TabArray.length)
  733.         {
  734.             for(int i = 0; i < par1ItemArray.length;i++)
  735.             {
  736.                 if(par3Int == 1)
  737.                 {
  738.                     par1ItemArray[i].setCreativeTab(par2TabArray[i]);
  739.                 }
  740.             }
  741.         }
  742.     }
  743.     public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, int[] par3IntArray)
  744.     {
  745.         if(par1BlockArray.length == par2TabArray.length)
  746.         {
  747.             if(par1BlockArray.length == par3IntArray.length)
  748.             {
  749.                 for(int i = 0; i < par1BlockArray.length; i++)
  750.                 {
  751.                     if(par3IntArray[i] == 1)
  752.                     {
  753.                         par1BlockArray[i].setCreativeTab(par2TabArray[i]);
  754.                     }
  755.                 }
  756.             }
  757.         }
  758.     }
  759.     public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, int[] par3IntArray)
  760.     {
  761.         if(par1ItemArray.length == par2TabArray.length)
  762.         {
  763.             if(par1ItemArray.length == par3IntArray.length)
  764.             {
  765.                 for(int i = 0; i < par1ItemArray.length; i++)
  766.                 {
  767.                     if(par3IntArray[i] == 1)
  768.                     {
  769.                         par1ItemArray[i].setCreativeTab(par2TabArray[i]);
  770.                     }
  771.                 }
  772.             }
  773.         }
  774.     }
  775.    
  776.    
  777.    
  778. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!