API tools faq
paste
View difference between Paste ID: SJmjgdgK and Yy7Vifpd
SHOW: | | - or go back to the newest paste.
1
// WARNING :
2
At this momment I am hard working on improve the code and I am porting this to MC 1.6.2
3
Because it isnt working no more (This uses deleted function .getUnlocalizedName2())
4
Thanks. A lot will be changed in some days.
5
6
// IMPORTS :

7
import mar21.omega.ModCore;

8
import net.minecraft.block.Block;

9
import net.minecraft.creativetab.CreativeTabs;

10
import net.minecraft.item.Item;

11
import net.minecraft.item.ItemStack;

12
import net.minecraft.item.crafting.FurnaceRecipes;

13
import cpw.mods.fml.common.registry.GameRegistry;

14
import cpw.mods.fml.common.registry.LanguageRegistry;

15
16
// CLASS :

17
{

18
	/**

19
	Minecraft modding m2cAPI created by mar21

20
  	Easy way to make your code short and compact

21
	You can use this m2cAPI if you have in mod description:

22
	   This mod is using the m2cAPI by mar21

23
	Else give a Karma or Thank You on MinecraftForge forum

24
	to my mar21 account. It will boost me with expanding

25
	the api code. Thanks very much

26
	Every pack of functions is marked with comment!

27
	If something doesnt work send me a pm on MCForge forum!

28
	**/

29
	

30
    // Block LanguageRegistry and GameRegistry //TODO

31
    public static void regBlock(Block par1Block, String par2String)

32
    {

33
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

34
        LanguageRegistry.addName(par1Block, par2String);

35
    }

36
    public static void regBlock(Block[] par1BlockArray, String[] par2StringArray)

37
    {

38
        if (par1BlockArray.length == par2StringArray.length)

39
        {

40
        	for (int i = 0; i < par1BlockArray.length; i++)

41
        	{

42
            	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

43
            	LanguageRegistry.addName(par1BlockArray[i], par2StringArray[i]);

44
        	}

45
        }

46
    }

47
    // Item LanguageRegistry //TODO

48
    public static void regItem(Item par1Item, String par2String)

49
    {

50
        LanguageRegistry.addName(par1Item, par2String);

51
    }

52
    public static void regItem(Item[] par1ItemArray, String[] par2StringArray)

53
    {

54
        if (par1ItemArray.length == par2StringArray.length);

55
        {

56
        	for (int i = 0; i < par1ItemArray.length; i++)

57
        	{

58
        		LanguageRegistry.addName(par1ItemArray[i], par2StringArray[i]);

59
        	}

60
        }

61
    }

62
    // Item and Block FurnaceRecipes.addSmelting() //TODO

63
    public static void regSmelting(Item par1Item, Item par2Item, Float par3Float)

64
    {

65
        FurnaceRecipes.smelting().addSmelting(par1Item.itemID, new ItemStack(par2Item), par3Float);

66
    }

67
    public static void regSmelting(Item par1Item, Block par2Block, Float par3Float)

68
    {

69
        FurnaceRecipes.smelting().addSmelting(par1Item.itemID, new ItemStack(par2Block), par3Float);

70
    }

71
    public static void regSmelting(Item[] par1ItemArray, Item[] par2ItemArray, Float[] par3FloatArray)

72
    {

73
        if (par1ItemArray.length == par2ItemArray.length);

74
        {

75
        	for (int i = 0; i < par1ItemArray.length; i++)

76
        	{

77
            	FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2ItemArray[i]), par3FloatArray[i]);

78
        	}

79
        }

80
    }

81
    public static void regSmelting(Item[] par1ItemArray, Item[] par2ItemArray, Float par3Float)

82
    {

83
        if (par1ItemArray.length == par2ItemArray.length);

84
        {

85
        	for (int i = 0; i < par1ItemArray.length; i++)

86
        	{

87
            	FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2ItemArray[i]), par3Float);

88
        	}

89
        }

90
    }

91
    public static void regSmelting(Item[] par1ItemArray, Block[] par2BlockArray, Float[] par3FloatArray)

92
    {

93
        if (par1ItemArray.length == par2BlockArray.length);

94
        {

95
        	for (int i = 0; i < par1ItemArray.length; i++)

96
        	{

97
            	FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2BlockArray[i]), par3FloatArray[i]);

98
        	}

99
        }

100
    }

101
    public static void regSmelting(Item[] par1ItemArray, Block[] par2BlockArray, Float par3Float)

102
    {

103
        if (par1ItemArray.length == par2BlockArray.length);

104
        {

105
        	for (int i = 0; i < par1ItemArray.length; i++)

106
        	{

107
            	FurnaceRecipes.smelting().addSmelting(par1ItemArray[i].itemID, new ItemStack(par2BlockArray[i]), par3Float);

108
        	}

109
        }

110
    }

111
    public static void regSmelting(Block par1Block, Item par2Item, Float par3Float)

112
    {

113
        FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par3Float);

114
    }

115
    public static void regSmelting(Block par1Block, Block par2Block, Float par3Float)

116
    {

117
        FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par3Float);

118
    }

119
    public static void regSmelting(Block[] par1BlockArray, Item[] par2ItemArray, Float[] par3FloatArray)

120
    {

121
        if (par1BlockArray.length == par2ItemArray.length)

122
        {

123
        	for (int i = 0; i < par1BlockArray.length; i++)

124
        	{

125
            	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par3FloatArray[i]);

126
        	}

127
        }

128
    }

129
    public static void regSmelting(Block[] par1BlockArray, Item[] par2ItemArray, Float par3Float)

130
    {

131
        if (par1BlockArray.length == par2ItemArray.length)

132
        {

133
        	for(int i = 0; i < par1BlockArray.length; i++)

134
        	{

135
        		FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par3Float);

136
        	}

137
        }

138
    }

139
    public static void regSmelting(Block[] par1BlockArray, Block[] par2BlockArray, Float[] par3FloatArray)

140
    {

141
        if (par1BlockArray.length == par2BlockArray.length)

142
        {

143
        	for (int i = 0; i < par1BlockArray.length; i++)

144
        	{

145
        		FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par3FloatArray[i]);

146
        	}

147
        }

148
    }

149
    public static void regSmelting(Block[] par1BlockArray, Block[] par2BlockArray, Float par3Float)

150
    {

151
        if (par1BlockArray.length == par2BlockArray.length)

152
        {

153
        	for (int i = 0; i < par1BlockArray.length; i++)

154
        	{

155
            	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par3Float);

156
        	}

157
        }

158
    }

159
    // Ore LanguageRegistry,GameRegistry and smelting recipe into item or block //TODO

160
    public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float)

161
    {

162
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

163
        LanguageRegistry.addName(par1Block, par3String);

164
        FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float);

165
    }

166
    public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float)

167
    {

168
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

169
        LanguageRegistry.addName(par1Block, par3String);

170
        FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);

171
    }

172
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray)

173
    {

174
        if (par1BlockArray.length == par2BlockArray.length)

175
        {

176
        	for (int i = 0; i < par1BlockArray.length; i++)

177
        	{

178
           	 	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

179
           	 	LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

180
           	 	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);

181
        	}

182
    	}

183
    }

184
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float)

185
    {

186
        if (par1BlockArray.length == par2BlockArray.length)

187
        {

188
        	for (int i = 0; i < par1BlockArray.length; i++)

189
        	{

190
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

191
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

192
        		FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);

193
        	}

194
        }

195
    }

196
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray)

197
    {

198
        if (par1BlockArray.length == par2ItemArray.length)

199
        {

200
        	for (int i = 0; i < par1BlockArray.length; i++)

201
        	{

202
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

203
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

204
        		FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);

205
        	}

206
    	}

207
    }

208
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float)

209
    {

210
        if (par1BlockArray.length == par2ItemArray.length)

211
        {

212
        	for (int i = 0; i < par1BlockArray.length; i++)

213
        	{

214
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

215
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

216
        		FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);

217
        	}

218
        }

219
    }

220
    // Ore LanguageRegistry,GameRegistry and toggleable smelting recipe into item or block - boolean //TODO

221
    public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float, Boolean par5Boolean)

222
    {

223
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

224
        LanguageRegistry.addName(par1Block, par3String);

225
        if(par5Boolean == true)

226
        {

227
        	FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float);	

228
        }

229
    }

230
    public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float, Boolean par5Boolean)

231
    {

232
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

233
        LanguageRegistry.addName(par1Block, par3String);

234
        if(par5Boolean == true)

235
        {

236
        	FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);

237
        }

238
    }

239
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, Boolean par5Boolean)

240
    {

241
        if (par1BlockArray.length == par2BlockArray.length)

242
        {

243
        	for (int i = 0; i < par1BlockArray.length; i++)

244
        	{

245
           	 	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

246
           	 	LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

247
           	 	if(par5Boolean == true)

248
           	 	{

249
           	 	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);

250
           	 	}

251
        	}

252
    	}

253
    }

254
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, Boolean[] par5BooleanArray)

255
    {

256
        if (par1BlockArray.length == par2BlockArray.length)

257
        {

258
        	for (int i = 0; i < par1BlockArray.length; i++)

259
        	{

260
           	 	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

261
           	 	LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

262
           	 	if(par5BooleanArray[i] == true)

263
           	 	{

264
           	 	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);

265
           	 	}

266
        	}

267
    	}

268
    }

269
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, Boolean par5Boolean)

270
    {

271
        if (par1BlockArray.length == par2BlockArray.length)

272
        {

273
        	for (int i = 0; i < par1BlockArray.length; i++)

274
        	{

275
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

276
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

277
        		if(par5Boolean == true)

278
        		{

279
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);

280
        		}

281
        	}

282
        }

283
    }

284
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, Boolean[] par5BooleanArray)

285
    {

286
        if (par1BlockArray.length == par2BlockArray.length)

287
        {

288
        	for (int i = 0; i < par1BlockArray.length; i++)

289
        	{

290
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

291
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

292
        		if(par5BooleanArray[i] == true)

293
        		{

294
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);

295
        		}

296
        	}

297
        }

298
    }

299
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, Boolean par5Boolean)

300
    {

301
        if (par1BlockArray.length == par2ItemArray.length)

302
        {

303
        	for (int i = 0; i < par1BlockArray.length; i++)

304
        	{

305
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

306
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

307
        		if(par5Boolean == true)

308
        		{

309
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);

310
        		}

311
        	}

312
    	}

313
    }

314
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, Boolean[] par5BooleanArray)

315
    {

316
        if (par1BlockArray.length == par2ItemArray.length)

317
        {

318
        	for (int i = 0; i < par1BlockArray.length; i++)

319
        	{

320
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

321
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

322
        		if(par5BooleanArray[i] == true)

323
        		{

324
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);

325
        		}

326
        	}

327
    	}

328
    }

329
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, Boolean par5Boolean)

330
    {

331
        if (par1BlockArray.length == par2ItemArray.length)

332
        {

333
        	for (int i = 0; i < par1BlockArray.length; i++)

334
        	{

335
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

336
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

337
        		if(par5Boolean == true)

338
        		{

339
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);

340
        		}

341
        	}

342
        }

343
    }

344
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, Boolean[] par5BooleanArray)

345
    {

346
        if (par1BlockArray.length == par2ItemArray.length)

347
        {

348
        	for (int i = 0; i < par1BlockArray.length; i++)

349
        	{

350
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

351
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

352
        		if(par5BooleanArray[i] == true)

353
        		{

354
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);

355
        		}

356
        	}

357
        }

358
    }

359
    // Ore LanguageRegistry,GameRegistry and toggleable smelting recipe into item or block -integer //TODO

360
    public static void regOre(Block par1Block, Block par2Block, String par3String, Float par4Float, int par5Int)

361
    {

362
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

363
        LanguageRegistry.addName(par1Block, par3String);

364
        if(par5Int == 1)

365
        {

366
        	FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Block), par4Float);	

367
        }

368
    }

369
    public static void regOre(Block par1Block, Item par2Item, String par3String, Float par4Float, int par5Int)

370
    {

371
        GameRegistry.registerBlock(par1Block, ModCore.modid + par1Block.getUnlocalizedName2());

372
        LanguageRegistry.addName(par1Block, par3String);

373
        if(par5Int == 1)

374
        {

375
        	FurnaceRecipes.smelting().addSmelting(par1Block.blockID, new ItemStack(par2Item), par4Float);

376
        }

377
    }

378
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, int par5Int)

379
    {

380
        if (par1BlockArray.length == par2BlockArray.length)

381
        {

382
        	for (int i = 0; i < par1BlockArray.length; i++)

383
        	{

384
           	 	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

385
           	 	LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

386
           	 	if(par5Int == 1)

387
           	 	{

388
           	 	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);

389
           	 	}

390
        	}

391
    	}

392
    }

393
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float[] par4FloatArray, int[] par5IntArray)

394
    {

395
        if (par1BlockArray.length == par2BlockArray.length)

396
        {

397
        	for (int i = 0; i < par1BlockArray.length; i++)

398
        	{

399
           	 	GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

400
           	 	LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

401
           	 	if(par5IntArray[i] == 1)

402
           	 	{

403
           	 	FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4FloatArray[i]);

404
           	 	}

405
        	}

406
    	}

407
    }

408
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, int par5Int)

409
    {

410
        if (par1BlockArray.length == par2BlockArray.length)

411
        {

412
        	for (int i = 0; i < par1BlockArray.length; i++)

413
        	{

414
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

415
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

416
        		if(par5Int == 1)

417
        		{

418
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);

419
        		}

420
        	}

421
        }

422
    }

423
    public static void regOre(Block[] par1BlockArray, Block[] par2BlockArray, String[] par3StringArray, Float par4Float, int[] par5IntArray)

424
    {

425
        if (par1BlockArray.length == par2BlockArray.length)

426
        {

427
        	for (int i = 0; i < par1BlockArray.length; i++)

428
        	{

429
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

430
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

431
        		if(par5IntArray[i] == 1)

432
        		{

433
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2BlockArray[i]), par4Float);

434
        		}

435
        	}

436
        }

437
    }

438
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, int par5Int)

439
    {

440
        if (par1BlockArray.length == par2ItemArray.length)

441
        {

442
        	for (int i = 0; i < par1BlockArray.length; i++)

443
        	{

444
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

445
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

446
        		if(par5Int == 1)

447
        		{

448
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);

449
        		}

450
        	}

451
    	}

452
    }

453
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float[] par4FloatArray, int[] par5IntArray)

454
    {

455
        if (par1BlockArray.length == par2ItemArray.length)

456
        {

457
        	for (int i = 0; i < par1BlockArray.length; i++)

458
        	{

459
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

460
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

461
        		if(par5IntArray[i] == 1)

462
        		{

463
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4FloatArray[i]);

464
        		}

465
        	}

466
    	}

467
    }

468
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, int par5Int)

469
    {

470
        if (par1BlockArray.length == par2ItemArray.length)

471
        {

472
        	for (int i = 0; i < par1BlockArray.length; i++)

473
        	{

474
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

475
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

476
        		if(par5Int == 1)

477
        		{

478
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);

479
        		}

480
        	}

481
        }

482
    }

483
    public static void regOre(Block[] par1BlockArray, Item[] par2ItemArray, String[] par3StringArray, Float par4Float, int[] par5IntArray)

484
    {

485
        if (par1BlockArray.length == par2ItemArray.length)

486
        {

487
        	for (int i = 0; i < par1BlockArray.length; i++)

488
        	{

489
        		GameRegistry.registerBlock(par1BlockArray[i], ModCore.modid + par1BlockArray[i].getUnlocalizedName2());

490
        		LanguageRegistry.addName(par1BlockArray[i], par3StringArray[i]);

491
        		if(par5IntArray[i] == 1)

492
        		{

493
        			FurnaceRecipes.smelting().addSmelting(par1BlockArray[i].blockID, new ItemStack(par2ItemArray[i]), par4Float);

494
        		}

495
        	}

496
        }

497
    }

498
    //TODO

499
    

500
    // Metadata LanguageRegistry //TODO

501
    public static void regMeta(Block[] par1BlockArray,String[] par2StringArray)

502
    {

503
    	if(par1BlockArray.length == par2StringArray.length)

504
    	{

505
    		for(int i = 0; i < par1BlockArray.length ; i++)

506
    		{

507
    			LanguageRegistry.addName(new ItemStack(par1BlockArray[i], 1, i), par2StringArray[i]);

508
    		}

509
    	}

510
    }

511
    public static void regMeta(Item[] par1ItemArray,String[] par2StringArray)

512
    {

513
    	if(par1ItemArray.length == par2StringArray.length)

514
    	{

515
    		for(int i = 0; i < par1ItemArray.length ; i++)

516
    		{

517
    			LanguageRegistry.addName(new ItemStack(par1ItemArray[i], 1, i), par2StringArray[i]);

518
    		}

519
    	}

520
    }

521
    // Simple .setCreativeTab() //TODO

522
    public static void regTab(Block par1Block, CreativeTabs par1CreativeTab)

523
    {

524
        par1Block.setCreativeTab(par1CreativeTab);

525
    }

526
    public static void regTab(Item par1Item, CreativeTabs par1CreativeTab)

527
    {

528
        par1Item.setCreativeTab(par1CreativeTab);

529
    }

530
    public static void regTab(Block[] par1BlockArray, CreativeTabs par1CreativeTab)

531
    {

532
        for (int i = 0; i < par1BlockArray.length; i++)

533
        {

534
            par1BlockArray[i].setCreativeTab(par1CreativeTab);

535
        }

536
    }

537
    public static void regTab(Item[] par1ItemArray, CreativeTabs par1CreativeTab)

538
    {

539
        for (int i = 0; i < par1ItemArray.length; i++)

540
        {

541
            par1ItemArray[i].setCreativeTab(par1CreativeTab);

542
        }

543
    }

544
    public static void regTab(Block[] par1BlockArray, CreativeTabs[] par1CreativeTabArray)

545
    {

546
        for (int i = 0; i < par1BlockArray.length; i++)

547
        {

548
            par1BlockArray[i].setCreativeTab(par1CreativeTabArray[i]);

549
        }

550
    }

551
    public static void regTab(Item[] par1ItemArray, CreativeTabs[] par1CreativeTabArray)

552
    {

553
        for (int i = 0; i < par1ItemArray.length; i++)

554
        {

555
            par1ItemArray[i].setCreativeTab(par1CreativeTabArray[i]);

556
        }

557
    }

558
    // Toggleable .setCreativeTab() - boolean //TODO

559
    public static void regTab(Block par1Block, CreativeTabs par2Tab, Boolean par3Boolean)

560
    {

561
    	if(par3Boolean == true)

562
    	{

563
    		par1Block.setCreativeTab(par2Tab);

564
    	}

565
    }

566
    public static void regTab(Item par1Item, CreativeTabs par2Tab, Boolean par3Boolean)

567
    {

568
    	if(par3Boolean == true)

569
    	{

570
    		par1Item.setCreativeTab(par2Tab);

571
    	}

572
    }

573
    public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, Boolean par3Boolean)

574
    {

575
    	for(int i = 0; i < par1ItemArray.length ; i++)

576
    		{

577
    		if(par3Boolean == true)

578
    			{

579
    			par1ItemArray[i].setCreativeTab(par2Tab);	

580
    			}

581
    		}

582
    }

583
    public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, Boolean par3Boolean)

584
    {

585
    	for(int i = 0; i < par1BlockArray.length ; i++)

586
		{

587
			if(par3Boolean == true)

588
			{

589
				par1BlockArray[i].setCreativeTab(par2Tab);

590
			}

591
		}

592
    }

593
    public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, Boolean[] par3BooleanArray)

594
    {

595
    	if(par1BlockArray.length == par3BooleanArray.length)

596
    	{

597
    		for(int i = 0; i < par1BlockArray.length;i++)

598
    		{

599
    			if(par3BooleanArray[i] == true)

600
    			{

601
    				par1BlockArray[i].setCreativeTab(par2Tab);

602
    			}

603
    		}

604
    	}

605
    }

606
    public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, Boolean[] par3BooleanArray)

607
    {

608
    	if(par1ItemArray.length == par3BooleanArray.length)

609
    	{

610
    		for(int i = 0; i < par1ItemArray.length;i++)

611
    		{

612
    			if(par3BooleanArray[i] == true)

613
    			{

614
    				par1ItemArray[i].setCreativeTab(par2Tab);

615
    			}

616
    		}

617
    	}

618
    }

619
    public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, Boolean par3Boolean)

620
    {

621
    	if(par1BlockArray.length == par2TabArray.length)

622
    	{

623
    		for(int i = 0; i < par1BlockArray.length;i++)

624
    		{

625
    			if(par3Boolean == true)

626
    			{

627
    				par1BlockArray[i].setCreativeTab(par2TabArray[i]);

628
    			}

629
    		}

630
    	}

631
    }

632
    public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, Boolean par3Boolean)

633
    {

634
    	if(par1ItemArray.length == par2TabArray.length)

635
    	{

636
    		for(int i = 0; i < par1ItemArray.length;i++)

637
    		{

638
    			if(par3Boolean == true)

639
    			{

640
    				par1ItemArray[i].setCreativeTab(par2TabArray[i]);

641
    			}

642
    		}

643
    	}

644
    }

645
    public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, Boolean[] par3BooleanArray)

646
    {

647
    	if(par1BlockArray.length == par2TabArray.length)

648
    	{

649
    		if(par1BlockArray.length == par3BooleanArray.length)

650
    		{

651
    			for(int i = 0; i < par1BlockArray.length; i++)

652
    			{

653
    				if(par3BooleanArray[i] == true)

654
    				{

655
    					par1BlockArray[i].setCreativeTab(par2TabArray[i]);

656
    				}

657
    			}

658
    		}

659
    	}

660
    }

661
    // Toggleable .setCreativeTab() - integer //TODO

662
    public static void regTab(Block par1Block, CreativeTabs par2Tab, int par3Int)

663
    {

664
    	if(par3Int == 1)

665
    	{

666
    		par1Block.setCreativeTab(par2Tab);

667
    	}

668
    }

669
    public static void regTab(Item par1Item, CreativeTabs par2Tab, int par3Int)

670
    {

671
    	if(par3Int == 1)

672
    	{

673
    		par1Item.setCreativeTab(par2Tab);

674
    	}

675
    }

676
    public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, int par3Int)

677
    {

678
    	for(int i = 0; i < par1ItemArray.length ; i++)

679
    			{

680
    				if(par3Int == 1)

681
    				{

682
    					par1ItemArray[i].setCreativeTab(par2Tab);

683
    				}

684
    			}

685
    }

686
    public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, int par3Int)

687
    {

688
    	for(int i = 0; i < par1BlockArray.length ; i++)

689
		{

690
    		if(par3Int == 1)

691
    		{

692
    			par1BlockArray[i].setCreativeTab(par2Tab);

693
    		}

694
		}

695
    }

696
    public static void regTab(Block[] par1BlockArray, CreativeTabs par2Tab, int[] par3IntArray)

697
    {

698
    	if(par1BlockArray.length == par3IntArray.length)

699
    	{

700
    		for(int i = 0; i < par1BlockArray.length;i++)

701
    		{

702
    			if(par3IntArray[i] == 1)

703
    			{

704
    				par1BlockArray[i].setCreativeTab(par2Tab);

705
    			}

706
    		}

707
    	}

708
    }

709
    public static void regTab(Item[] par1ItemArray, CreativeTabs par2Tab, int[] par3IntArray)

710
    {

711
    	if(par1ItemArray.length == par3IntArray.length)

712
    	{

713
    		for(int i = 0; i < par1ItemArray.length;i++)

714
    		{

715
    			if(par3IntArray[i] == 1)

716
    			{

717
    				par1ItemArray[i].setCreativeTab(par2Tab);

718
    			}

719
    		}

720
    	}

721
    }

722
    public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, int par3Int)

723
    {

724
    	if(par1BlockArray.length == par2TabArray.length)

725
    	{

726
    		for(int i = 0; i < par1BlockArray.length;i++)

727
    		{

728
    			if(par3Int == 1)

729
    			{

730
    				par1BlockArray[i].setCreativeTab(par2TabArray[i]);

731
    			}

732
    		}

733
    	}

734
    }

735
    public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, int par3Int)

736
    {

737
    	if(par1ItemArray.length == par2TabArray.length)

738
    	{

739
    		for(int i = 0; i < par1ItemArray.length;i++)

740
    		{

741
    			if(par3Int == 1)

742
    			{

743
    				par1ItemArray[i].setCreativeTab(par2TabArray[i]);

744
    			}

745
    		}

746
    	}

747
    }

748
    public static void regTab(Block[] par1BlockArray, CreativeTabs[] par2TabArray, int[] par3IntArray)

749
    {

750
    	if(par1BlockArray.length == par2TabArray.length)

751
    	{

752
    		if(par1BlockArray.length == par3IntArray.length)

753
    		{

754
    			for(int i = 0; i < par1BlockArray.length; i++)

755
    			{

756
    				if(par3IntArray[i] == 1)

757
    				{

758
    					par1BlockArray[i].setCreativeTab(par2TabArray[i]);

759
    				}

760
    			}

761
    		}

762
    	}

763
    }

764
    public static void regTab(Item[] par1ItemArray, CreativeTabs[] par2TabArray, int[] par3IntArray)

765
    {

766
        if(par1ItemArray.length == par2TabArray.length)

767
        {

768
        	if(par1ItemArray.length == par3IntArray.length)

769
        	{

770
        		for(int i = 0; i < par1ItemArray.length; i++)

771
        		{

772
        			if(par3IntArray[i] == 1)

773
        			{

774
        				par1ItemArray[i].setCreativeTab(par2TabArray[i]);

775
        			}

776
        		}

777
        	}

778
       	}

779
    }

780
    

781
    

782
    

783
}
        

    


            


                                


        

            



                
    

        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!