generated from tilera/1710mod
1224 lines
57 KiB
Java
1224 lines
57 KiB
Java
package com.eloraam.redpower;
|
|
|
|
import com.eloraam.redpower.core.AchieveLib;
|
|
import com.eloraam.redpower.core.Config;
|
|
import com.eloraam.redpower.core.CoreLib;
|
|
import com.eloraam.redpower.core.CraftLib;
|
|
import com.eloraam.redpower.core.ItemExtended;
|
|
import com.eloraam.redpower.core.ItemParts;
|
|
import com.eloraam.redpower.core.ItemTextured;
|
|
import com.eloraam.redpower.core.RenderLib;
|
|
import com.eloraam.redpower.machine.BlockFrame;
|
|
import com.eloraam.redpower.machine.BlockMachine;
|
|
import com.eloraam.redpower.machine.BlockMachinePanel;
|
|
import com.eloraam.redpower.machine.ContainerAssemble;
|
|
import com.eloraam.redpower.machine.ContainerBatteryBox;
|
|
import com.eloraam.redpower.machine.ContainerBlueAlloyFurnace;
|
|
import com.eloraam.redpower.machine.ContainerBlueFurnace;
|
|
import com.eloraam.redpower.machine.ContainerBufferChest;
|
|
import com.eloraam.redpower.machine.ContainerChargingBench;
|
|
import com.eloraam.redpower.machine.ContainerDeploy;
|
|
import com.eloraam.redpower.machine.ContainerEject;
|
|
import com.eloraam.redpower.machine.ContainerFilter;
|
|
import com.eloraam.redpower.machine.ContainerItemDetect;
|
|
import com.eloraam.redpower.machine.ContainerManager;
|
|
import com.eloraam.redpower.machine.ContainerRegulator;
|
|
import com.eloraam.redpower.machine.ContainerRetriever;
|
|
import com.eloraam.redpower.machine.ContainerSorter;
|
|
import com.eloraam.redpower.machine.ContainerWindTurbine;
|
|
import com.eloraam.redpower.machine.GuiAssemble;
|
|
import com.eloraam.redpower.machine.GuiBatteryBox;
|
|
import com.eloraam.redpower.machine.GuiBlueAlloyFurnace;
|
|
import com.eloraam.redpower.machine.GuiBlueFurnace;
|
|
import com.eloraam.redpower.machine.GuiBufferChest;
|
|
import com.eloraam.redpower.machine.GuiChargingBench;
|
|
import com.eloraam.redpower.machine.GuiDeploy;
|
|
import com.eloraam.redpower.machine.GuiEject;
|
|
import com.eloraam.redpower.machine.GuiFilter;
|
|
import com.eloraam.redpower.machine.GuiItemDetect;
|
|
import com.eloraam.redpower.machine.GuiManager;
|
|
import com.eloraam.redpower.machine.GuiRegulator;
|
|
import com.eloraam.redpower.machine.GuiRetriever;
|
|
import com.eloraam.redpower.machine.GuiSorter;
|
|
import com.eloraam.redpower.machine.GuiWindTurbine;
|
|
import com.eloraam.redpower.machine.ItemBattery;
|
|
import com.eloraam.redpower.machine.ItemMachinePanel;
|
|
import com.eloraam.redpower.machine.ItemSonicDriver;
|
|
import com.eloraam.redpower.machine.ItemVoltmeter;
|
|
import com.eloraam.redpower.machine.ItemWindmill;
|
|
import com.eloraam.redpower.machine.MicroPlacementTube;
|
|
import com.eloraam.redpower.machine.RenderAccel;
|
|
import com.eloraam.redpower.machine.RenderBatteryBox;
|
|
import com.eloraam.redpower.machine.RenderBlueAlloyFurnace;
|
|
import com.eloraam.redpower.machine.RenderBlueFurnace;
|
|
import com.eloraam.redpower.machine.RenderBreaker;
|
|
import com.eloraam.redpower.machine.RenderBufferChest;
|
|
import com.eloraam.redpower.machine.RenderChargingBench;
|
|
import com.eloraam.redpower.machine.RenderFrame;
|
|
import com.eloraam.redpower.machine.RenderFrameMoving;
|
|
import com.eloraam.redpower.machine.RenderFrameRedstoneTube;
|
|
import com.eloraam.redpower.machine.RenderFrameTube;
|
|
import com.eloraam.redpower.machine.RenderGrate;
|
|
import com.eloraam.redpower.machine.RenderMachine;
|
|
import com.eloraam.redpower.machine.RenderMotor;
|
|
import com.eloraam.redpower.machine.RenderPipe;
|
|
import com.eloraam.redpower.machine.RenderPump;
|
|
import com.eloraam.redpower.machine.RenderRedstoneTube;
|
|
import com.eloraam.redpower.machine.RenderSolarPanel;
|
|
import com.eloraam.redpower.machine.RenderThermopile;
|
|
import com.eloraam.redpower.machine.RenderTransformer;
|
|
import com.eloraam.redpower.machine.RenderTube;
|
|
import com.eloraam.redpower.machine.RenderWindTurbine;
|
|
import com.eloraam.redpower.machine.TileAccel;
|
|
import com.eloraam.redpower.machine.TileAssemble;
|
|
import com.eloraam.redpower.machine.TileBatteryBox;
|
|
import com.eloraam.redpower.machine.TileBlueAlloyFurnace;
|
|
import com.eloraam.redpower.machine.TileBlueFurnace;
|
|
import com.eloraam.redpower.machine.TileBreaker;
|
|
import com.eloraam.redpower.machine.TileBufferChest;
|
|
import com.eloraam.redpower.machine.TileChargingBench;
|
|
import com.eloraam.redpower.machine.TileDeploy;
|
|
import com.eloraam.redpower.machine.TileEject;
|
|
import com.eloraam.redpower.machine.TileEjectBase;
|
|
import com.eloraam.redpower.machine.TileFilter;
|
|
import com.eloraam.redpower.machine.TileFrame;
|
|
import com.eloraam.redpower.machine.TileFrameMoving;
|
|
import com.eloraam.redpower.machine.TileFrameRedstoneTube;
|
|
import com.eloraam.redpower.machine.TileFrameTube;
|
|
import com.eloraam.redpower.machine.TileGrate;
|
|
import com.eloraam.redpower.machine.TileIgniter;
|
|
import com.eloraam.redpower.machine.TileItemDetect;
|
|
import com.eloraam.redpower.machine.TileMachine;
|
|
import com.eloraam.redpower.machine.TileMagTube;
|
|
import com.eloraam.redpower.machine.TileManager;
|
|
import com.eloraam.redpower.machine.TileMotor;
|
|
import com.eloraam.redpower.machine.TilePipe;
|
|
import com.eloraam.redpower.machine.TilePump;
|
|
import com.eloraam.redpower.machine.TileRedstoneTube;
|
|
import com.eloraam.redpower.machine.TileRegulator;
|
|
import com.eloraam.redpower.machine.TileRelay;
|
|
import com.eloraam.redpower.machine.TileRestrictTube;
|
|
import com.eloraam.redpower.machine.TileRetriever;
|
|
import com.eloraam.redpower.machine.TileSolarPanel;
|
|
import com.eloraam.redpower.machine.TileSorter;
|
|
import com.eloraam.redpower.machine.TileSortron;
|
|
import com.eloraam.redpower.machine.TileThermopile;
|
|
import com.eloraam.redpower.machine.TileTransformer;
|
|
import com.eloraam.redpower.machine.TileTranspose;
|
|
import com.eloraam.redpower.machine.TileTube;
|
|
import com.eloraam.redpower.machine.TileWindTurbine;
|
|
import cpw.mods.fml.client.registry.ClientRegistry;
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
|
import cpw.mods.fml.common.Mod;
|
|
import cpw.mods.fml.common.Mod.EventHandler;
|
|
import cpw.mods.fml.common.Mod.Instance;
|
|
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
|
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
|
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
|
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
|
import cpw.mods.fml.common.network.IGuiHandler;
|
|
import cpw.mods.fml.common.network.NetworkRegistry;
|
|
import cpw.mods.fml.common.registry.GameRegistry;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import net.minecraft.client.renderer.texture.TextureMap;
|
|
import net.minecraft.creativetab.CreativeTabs;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.init.Items;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.stats.AchievementList;
|
|
import net.minecraft.util.IIcon;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.client.event.TextureStitchEvent.Pre;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
|
|
@Mod(
|
|
modid = "RedPowerMachine",
|
|
name = "RedPower Machine",
|
|
version = "2.0pr6",
|
|
dependencies = "required-after:RedPowerBase"
|
|
)
|
|
public class RedPowerMachine implements IGuiHandler {
|
|
@Instance("RedPowerMachine")
|
|
public static RedPowerMachine instance;
|
|
public static BlockMachine blockMachine;
|
|
public static BlockMachine blockMachine2;
|
|
public static BlockMachinePanel blockMachinePanel;
|
|
public static BlockFrame blockFrame;
|
|
public static ItemVoltmeter itemVoltmeter;
|
|
public static ItemSonicDriver itemSonicDriver;
|
|
public static Item itemBatteryEmpty;
|
|
public static Item itemBatteryPowered;
|
|
public static ItemParts itemMachineParts;
|
|
public static ItemStack itemWoodSail;
|
|
public static Item itemWoodTurbine;
|
|
public static Item itemWoodWindmill;
|
|
public static boolean FrameAlwaysCrate;
|
|
public static int FrameLinkSize;
|
|
public static boolean AllowGrateDump;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon frameCrossed;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon frameCovered;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon framePaneled;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon crate;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon baseTubeSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon baseTubeFace;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon baseTubeSideColor;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon baseTubeFaceColor;
|
|
public static IIcon[] redstoneTubeSide = new IIcon[4];
|
|
public static IIcon[] redstoneTubeFace = new IIcon[4];
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon pipeSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon pipeFace;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon pipeFlanges;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon restrictTubeSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon restrictTubeFace;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon restrictTubeSideColor;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon restrictTubeFaceColor;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon magTubeSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon magTubeRing;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon magTubeFace;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon magTubeSideNR;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon magTubeFaceNR;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon tubeItemOverlay;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon electronicsBottom;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon batteryTop;
|
|
public static IIcon[] batterySide = new IIcon[9];
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverSideCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon retrieverSideChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon transposerFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon transposerSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon transposerSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon filterSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon filterSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon breakerFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon breakerFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon breakerBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon breakerSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon breakerSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon deployerBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon deployerFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon deployerFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon deployerSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon deployerSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorBottom;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorFrontCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorFrontActive;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon motorTopActive;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon turbineFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon turbineSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon turbineSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon thermopileFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon thermopileSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon thermopileTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btFurnaceTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btFurnaceSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btFurnaceFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btFurnaceFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btAlloyFurnaceTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btAlloyFurnaceSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btAlloyFurnaceFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btAlloyFurnaceFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btChargerTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btChargerTopOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btChargerBottom;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btChargerSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon btChargerSideOn;
|
|
public static IIcon[] btChargerFront = new IIcon[6];
|
|
public static IIcon[] btChargerFrontPowered = new IIcon[5];
|
|
public static IIcon[] btChargerFrontActive = new IIcon[5];
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon bufferFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon bufferBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon bufferSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterBackCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterBackChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterSideCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sorterSideChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSideAltOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSideCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon detectorSideChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSideAltCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSideCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon regulatorSideChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSideAltCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSideCharged;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon sortronSideChargedOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon managerFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon managerBack;
|
|
public static IIcon[] managerSide = new IIcon[4];
|
|
public static IIcon[] managerSideCharged = new IIcon[4];
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerBackOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon igniterFront;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon igniterFrontOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon igniterSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon igniterSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon assemblerSideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon ejectorSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon ejectorSideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon relaySide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon relaySideOn;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon relaySideAlt;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon solarPanelTop;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon solarPanelSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon grateSide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon grateBack;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon grateMossySide;
|
|
@SideOnly(Side.CLIENT)
|
|
public static IIcon grateEmptyBack;
|
|
|
|
@EventHandler
|
|
public void preInit(FMLPreInitializationEvent event) {
|
|
}
|
|
|
|
@EventHandler
|
|
public void load(FMLInitializationEvent event) {
|
|
FrameAlwaysCrate = Config.getInt("settings.machine.frame.alwayscrate", 0) > 0;
|
|
FrameLinkSize = Config.getInt("settings.machine.frame.linksize", 1000);
|
|
AllowGrateDump = Config.getInt("settings.machine.frame.allowgratedump", 1) > 0;
|
|
setupItems();
|
|
setupBlocks();
|
|
initAchievements();
|
|
if (FMLCommonHandler.instance().getSide().isClient()) {
|
|
this.registerRenderers();
|
|
}
|
|
|
|
NetworkRegistry.INSTANCE.registerGuiHandler(instance, instance);
|
|
if (FMLCommonHandler.instance().getSide().isClient()) {
|
|
MinecraftForge.EVENT_BUS.register(instance);
|
|
}
|
|
|
|
}
|
|
|
|
@EventHandler
|
|
public void postInit(FMLPostInitializationEvent event) {
|
|
}
|
|
|
|
private static void setupItems() {
|
|
itemVoltmeter = new ItemVoltmeter();
|
|
itemBatteryEmpty = new ItemTextured("rpmachine:battery").setUnlocalizedName("btbattery").setCreativeTab(CreativeTabs.tabRedstone);
|
|
itemBatteryPowered = new ItemBattery();
|
|
CraftLib.addOreRecipe(new ItemStack(itemVoltmeter), "WWW", "WNW", "CCC", 'W', "plankWood", 'N', RedPowerBase.itemNikolite, 'C', "ingotCopper");
|
|
GameRegistry.registerItem(itemVoltmeter, "voltmeter");
|
|
CraftLib.addOreRecipe(new ItemStack(itemBatteryEmpty, 1), "NCN", "NTN", "NCN", 'N', RedPowerBase.itemNikolite, 'C', "ingotCopper", 'T', "ingotTin");
|
|
GameRegistry.registerItem(itemBatteryEmpty, "batteryEmpty");
|
|
GameRegistry.registerItem(itemBatteryPowered, "batteryPowered");
|
|
itemSonicDriver = new ItemSonicDriver();
|
|
itemSonicDriver.setUnlocalizedName("sonicDriver").setTextureName("rpmachine:sonicScrewdriver");
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(itemSonicDriver, 1, itemSonicDriver.getMaxDamage()),
|
|
new Object[]{"E ", " R ", " B", 'R', RedPowerBase.itemIngotBrass, 'E', RedPowerBase.itemGreenSapphire, 'B', itemBatteryEmpty}
|
|
);
|
|
GameRegistry.registerItem(itemSonicDriver, "sonicDriver");
|
|
itemWoodTurbine = new ItemWindmill(1);
|
|
itemWoodWindmill = new ItemWindmill(2).setUnlocalizedName("windmillWood").setTextureName("rpmachine:windmill");
|
|
itemMachineParts = new ItemParts();
|
|
itemMachineParts.addItem(0, "rpmachine:windSailWood", "item.windSailWood");
|
|
itemWoodSail = new ItemStack(itemMachineParts, 1, 0);
|
|
GameRegistry.registerItem(itemMachineParts, "machineParts");
|
|
CraftLib.addOreRecipe(itemWoodSail, "CCS", "CCW", "CCS", 'C', RedPowerBase.itemCanvas, 'W', "plankWood", 'S', Items.stick);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(itemWoodTurbine), new Object[]{"SAS", "SAS", "SAS", 'S', itemWoodSail, 'A', new ItemStack(RedPowerBase.blockMicro, 1, 5905)}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(itemWoodWindmill), new Object[]{" S ", "SAS", " S ", 'S', itemWoodSail, 'A', new ItemStack(RedPowerBase.blockMicro, 1, 5905)}
|
|
);
|
|
GameRegistry.registerItem(itemWoodTurbine, "woodTurbine");
|
|
GameRegistry.registerItem(itemWoodWindmill, "woodWindmill");
|
|
}
|
|
|
|
private static void setupBlocks() {
|
|
blockMachine = new BlockMachine();
|
|
blockMachine.setBlockName("rpmachine");
|
|
GameRegistry.registerBlock(blockMachine, ItemExtended.class, "machine");
|
|
blockMachine.setBlockName(0, "rpdeploy");
|
|
blockMachine.setBlockName(1, "rpbreaker");
|
|
blockMachine.setBlockName(2, "rptranspose");
|
|
blockMachine.setBlockName(3, "rpfilter");
|
|
blockMachine.setBlockName(4, "rpitemdet");
|
|
blockMachine.setBlockName(5, "rpsorter");
|
|
blockMachine.setBlockName(6, "rpbatbox");
|
|
blockMachine.setBlockName(7, "rpmotor");
|
|
blockMachine.setBlockName(8, "rpretriever");
|
|
blockMachine.setBlockName(9, "rpkgen");
|
|
blockMachine.setBlockName(10, "rpregulate");
|
|
blockMachine.setBlockName(11, "rpthermo");
|
|
blockMachine.setBlockName(12, "rpignite");
|
|
blockMachine.setBlockName(13, "rpassemble");
|
|
blockMachine.setBlockName(14, "rpeject");
|
|
blockMachine.setBlockName(15, "rprelay");
|
|
GameRegistry.registerTileEntity(TileWindTurbine.class, "RPWind");
|
|
GameRegistry.registerTileEntity(TilePipe.class, "RPPipe");
|
|
GameRegistry.registerTileEntity(TilePump.class, "RPPump");
|
|
GameRegistry.registerTileEntity(TileTube.class, "RPTube");
|
|
GameRegistry.registerTileEntity(TileRedstoneTube.class, "RPRSTube");
|
|
GameRegistry.registerTileEntity(TileRestrictTube.class, "RPRTube");
|
|
GameRegistry.registerTileEntity(TileMagTube.class, "RPMTube");
|
|
GameRegistry.registerTileEntity(TileAccel.class, "RPAccel");
|
|
GameRegistry.registerTileEntity(TileDeploy.class, "RPDeploy");
|
|
GameRegistry.registerTileEntity(TileBreaker.class, "RPBreaker");
|
|
GameRegistry.registerTileEntity(TileTranspose.class, "RPTranspose");
|
|
GameRegistry.registerTileEntity(TileFilter.class, "RPFilter");
|
|
GameRegistry.registerTileEntity(TileItemDetect.class, "RPItemDet");
|
|
GameRegistry.registerTileEntity(TileSorter.class, "RPSorter");
|
|
GameRegistry.registerTileEntity(TileBatteryBox.class, "RPBatBox");
|
|
GameRegistry.registerTileEntity(TileMotor.class, "RPMotor");
|
|
GameRegistry.registerTileEntity(TileRetriever.class, "RPRetrieve");
|
|
GameRegistry.registerTileEntity(TileRegulator.class, "RPRegulate");
|
|
GameRegistry.registerTileEntity(TileThermopile.class, "RPThermo");
|
|
GameRegistry.registerTileEntity(TileIgniter.class, "RPIgnite");
|
|
GameRegistry.registerTileEntity(TileAssemble.class, "RPAssemble");
|
|
GameRegistry.registerTileEntity(TileEject.class, "RPEject");
|
|
GameRegistry.registerTileEntity(TileRelay.class, "RPRelay");
|
|
blockMachine.addTileEntityMapping(0, TileDeploy::new);
|
|
blockMachine.addTileEntityMapping(1, TileBreaker::new);
|
|
blockMachine.addTileEntityMapping(2, TileTranspose::new);
|
|
blockMachine.addTileEntityMapping(3, TileFilter::new);
|
|
blockMachine.addTileEntityMapping(4, TileItemDetect::new);
|
|
blockMachine.addTileEntityMapping(5, TileSorter::new);
|
|
blockMachine.addTileEntityMapping(6, TileBatteryBox::new);
|
|
blockMachine.addTileEntityMapping(7, TileMotor::new);
|
|
blockMachine.addTileEntityMapping(8, TileRetriever::new);
|
|
blockMachine.addTileEntityMapping(9, TileWindTurbine::new);
|
|
blockMachine.addTileEntityMapping(10, TileRegulator::new);
|
|
blockMachine.addTileEntityMapping(11, TileThermopile::new);
|
|
blockMachine.addTileEntityMapping(12, TileIgniter::new);
|
|
blockMachine.addTileEntityMapping(13, TileAssemble::new);
|
|
blockMachine.addTileEntityMapping(14, TileEject::new);
|
|
blockMachine.addTileEntityMapping(15, TileRelay::new);
|
|
blockMachine2 = new BlockMachine();
|
|
blockMachine.setBlockName("rpmachine2");
|
|
GameRegistry.registerBlock(blockMachine2, ItemExtended.class, "machine2");
|
|
blockMachine2.setBlockName(0, "rpsortron");
|
|
blockMachine2.setBlockName(1, "rpmanager");
|
|
GameRegistry.registerTileEntity(TileSortron.class, "RPSortron");
|
|
GameRegistry.registerTileEntity(TileManager.class, "RPManager");
|
|
blockMachine2.addTileEntityMapping(0, TileSortron::new);
|
|
blockMachine2.addTileEntityMapping(1, TileManager::new);
|
|
blockMachinePanel = new BlockMachinePanel();
|
|
GameRegistry.registerBlock(blockMachinePanel, ItemMachinePanel.class, "machinePanel");
|
|
GameRegistry.registerTileEntity(TileSolarPanel.class, "RPSolar");
|
|
GameRegistry.registerTileEntity(TileGrate.class, "RPGrate");
|
|
GameRegistry.registerTileEntity(TileTransformer.class, "RPXfmr");
|
|
blockMachinePanel.addTileEntityMapping(0, TileSolarPanel::new);
|
|
blockMachinePanel.addTileEntityMapping(1, TilePump::new);
|
|
blockMachinePanel.addTileEntityMapping(2, TileAccel::new);
|
|
blockMachinePanel.addTileEntityMapping(3, TileGrate::new);
|
|
blockMachinePanel.addTileEntityMapping(4, TileTransformer::new);
|
|
blockMachinePanel.setBlockName(0, "rpsolar");
|
|
blockMachinePanel.setBlockName(1, "rppump");
|
|
blockMachinePanel.setBlockName(2, "rpaccel");
|
|
blockMachinePanel.setBlockName(3, "rpgrate");
|
|
blockMachinePanel.setBlockName(4, "rptransformer");
|
|
GameRegistry.registerTileEntity(TileBlueFurnace.class, "RPBFurnace");
|
|
GameRegistry.registerTileEntity(TileBufferChest.class, "RPBuffer");
|
|
GameRegistry.registerTileEntity(TileBlueAlloyFurnace.class, "RPBAFurnace");
|
|
GameRegistry.registerTileEntity(TileChargingBench.class, "RPCharge");
|
|
RedPowerBase.blockAppliance.setBlockName(1, "rpbfurnace");
|
|
RedPowerBase.blockAppliance.addTileEntityMapping(1, TileBlueFurnace::new);
|
|
RedPowerBase.blockAppliance.setBlockName(2, "rpbuffer");
|
|
RedPowerBase.blockAppliance.addTileEntityMapping(2, TileBufferChest::new);
|
|
RedPowerBase.blockAppliance.setBlockName(4, "rpbafurnace");
|
|
RedPowerBase.blockAppliance.addTileEntityMapping(4, TileBlueAlloyFurnace::new);
|
|
RedPowerBase.blockAppliance.setBlockName(5, "rpcharge");
|
|
RedPowerBase.blockAppliance.addTileEntityMapping(5, TileChargingBench::new);
|
|
blockFrame = new BlockFrame();
|
|
GameRegistry.registerBlock(blockFrame, ItemExtended.class, "frame");
|
|
blockFrame.setBlockName("rpframe");
|
|
blockFrame.setBlockName(0, "rpframe");
|
|
blockFrame.setBlockName(2, "rptframe");
|
|
blockFrame.setBlockName(3, "rprtframe");
|
|
GameRegistry.registerTileEntity(TileFrame.class, "RPFrame");
|
|
GameRegistry.registerTileEntity(TileFrameMoving.class, "RPMFrame");
|
|
GameRegistry.registerTileEntity(TileFrameTube.class, "RPTFrame");
|
|
GameRegistry.registerTileEntity(TileFrameRedstoneTube.class, "RPRTFrame");
|
|
blockFrame.addTileEntityMapping(0, TileFrame::new);
|
|
blockFrame.addTileEntityMapping(1, TileFrameMoving::new);
|
|
blockFrame.addTileEntityMapping(2, TileFrameTube::new);
|
|
blockFrame.addTileEntityMapping(3, TileFrameRedstoneTube::new);
|
|
MicroPlacementTube imp = new MicroPlacementTube();
|
|
RedPowerBase.blockMicro.registerPlacement(7, imp);
|
|
RedPowerBase.blockMicro.registerPlacement(8, imp);
|
|
RedPowerBase.blockMicro.registerPlacement(9, imp);
|
|
RedPowerBase.blockMicro.registerPlacement(10, imp);
|
|
RedPowerBase.blockMicro.registerPlacement(11, imp);
|
|
RedPowerBase.blockMicro.addTileEntityMapping(7, TilePipe::new);
|
|
RedPowerBase.blockMicro.addTileEntityMapping(8, TileTube::new);
|
|
RedPowerBase.blockMicro.addTileEntityMapping(9, TileRedstoneTube::new);
|
|
RedPowerBase.blockMicro.addTileEntityMapping(10, TileRestrictTube::new);
|
|
RedPowerBase.blockMicro.addTileEntityMapping(11, TileMagTube::new);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 0),
|
|
new Object[]{"SCS", "SPS", "SRS", 'S', Blocks.cobblestone, 'C', Blocks.chest, 'R', Items.redstone, 'P', Blocks.piston}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 1),
|
|
new Object[]{"SAS", "SPS", "SRS", 'S', Blocks.cobblestone, 'A', Items.iron_pickaxe, 'R', Items.redstone, 'P', Blocks.piston}
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 2), "SSS", "WPW", "SRS", 'S', Blocks.cobblestone, 'R', Items.redstone, 'P', Blocks.piston, 'W', "plankWood"
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 3),
|
|
new Object[]{"SSS", "GPG", "SRS", 'S', Blocks.cobblestone, 'R', RedPowerBase.itemWaferRed, 'P', Blocks.piston, 'G', Items.gold_ingot}
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 4),
|
|
"BTB",
|
|
"RPR",
|
|
"WTW",
|
|
'B',
|
|
"ingotBrass",
|
|
'T',
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 2048),
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'W',
|
|
"plankWood",
|
|
'P',
|
|
Blocks.wooden_pressure_plate
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 5),
|
|
new Object[]{
|
|
"III", "RFR", "IBI", 'B', RedPowerBase.itemIngotBlue, 'R', RedPowerBase.itemWaferRed, 'F', new ItemStack(blockMachine, 1, 3), 'I', Items.iron_ingot
|
|
}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 8),
|
|
new Object[]{
|
|
"BLB",
|
|
"EFE",
|
|
"INI",
|
|
'N',
|
|
RedPowerBase.itemIngotBlue,
|
|
'B',
|
|
RedPowerBase.itemIngotBrass,
|
|
'E',
|
|
Items.ender_pearl,
|
|
'L',
|
|
Items.leather,
|
|
'F',
|
|
new ItemStack(blockMachine, 1, 3),
|
|
'I',
|
|
Items.iron_ingot
|
|
}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 9),
|
|
new Object[]{
|
|
"IBI", "IMI", "IUI", 'I', Items.iron_ingot, 'B', RedPowerBase.itemIngotBrass, 'M', RedPowerBase.itemMotor, 'U', RedPowerBase.itemIngotBlue
|
|
}
|
|
);
|
|
CraftLib.addOreRecipe(new ItemStack(RedPowerBase.blockAppliance, 1, 2), "BWB", "W W", "BWB", 'B', Blocks.iron_bars, 'W', "plankWood");
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 10),
|
|
"BCB",
|
|
"RDR",
|
|
"WCW",
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'B',
|
|
"ingotBrass",
|
|
'D',
|
|
new ItemStack(blockMachine, 1, 4),
|
|
'W',
|
|
"plankWood",
|
|
'C',
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 2)
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 11),
|
|
"CIC",
|
|
"WBW",
|
|
"CIC",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'B',
|
|
RedPowerBase.itemIngotBlue,
|
|
'W',
|
|
RedPowerBase.itemWaferBlue,
|
|
'C',
|
|
"ingotCopper"
|
|
);
|
|
CraftLib.addOreRecipe(new ItemStack(RedPowerBase.blockMicro, 8, 2048), "BGB", 'G', Blocks.glass, 'B', "ingotBrass");
|
|
GameRegistry.addShapelessRecipe(
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 2304), new Object[]{Items.redstone, new ItemStack(RedPowerBase.blockMicro, 1, 2048)}
|
|
);
|
|
GameRegistry.addShapelessRecipe(
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 2560), new Object[]{Items.iron_ingot, new ItemStack(RedPowerBase.blockMicro, 1, 2048)}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(RedPowerBase.blockMicro, 8, 2816),
|
|
new Object[]{"CCC", "OGO", "CCC", 'G', Blocks.glass, 'O', Blocks.obsidian, 'C', RedPowerBase.itemFineCopper}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 1),
|
|
new Object[]{"CCC", "C C", "IBI", 'C', Blocks.clay, 'B', RedPowerBase.itemIngotBlue, 'I', Items.iron_ingot}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 4),
|
|
new Object[]{"CCC", "C C", "IBI", 'C', Blocks.brick_block, 'B', RedPowerBase.itemIngotBlue, 'I', Items.iron_ingot}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachinePanel, 1, 0), new Object[]{"WWW", "WBW", "WWW", 'W', RedPowerBase.itemWaferBlue, 'B', RedPowerBase.itemIngotBlue}
|
|
);
|
|
GameRegistry.addRecipe(new ItemStack(blockMachinePanel, 1, 2), new Object[]{"BOB", "O O", "BOB", 'O', Blocks.obsidian, 'B', RedPowerBase.itemIngotBlue});
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 6),
|
|
"BWB",
|
|
"BIB",
|
|
"IAI",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'W',
|
|
"plankWood",
|
|
'A',
|
|
RedPowerBase.itemIngotBlue,
|
|
'B',
|
|
itemBatteryEmpty
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachinePanel, 1, 4),
|
|
new Object[]{"III", "CIC", "BIB", 'I', Items.iron_ingot, 'C', RedPowerBase.itemCopperCoil, 'B', RedPowerBase.itemIngotBlue}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine2, 1, 0),
|
|
new Object[]{
|
|
"IDI",
|
|
"RSR",
|
|
"IWI",
|
|
'D',
|
|
Items.diamond,
|
|
'I',
|
|
Items.iron_ingot,
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'W',
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 3072),
|
|
'S',
|
|
new ItemStack(blockMachine, 1, 5)
|
|
}
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine2, 1, 1),
|
|
"IMI",
|
|
"RSR",
|
|
"WBW",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'S',
|
|
new ItemStack(blockMachine, 1, 5),
|
|
'M',
|
|
new ItemStack(blockMachine, 1, 10),
|
|
'W',
|
|
"plankWood",
|
|
'B',
|
|
RedPowerBase.itemIngotBlue
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 5),
|
|
"OQO",
|
|
"BCB",
|
|
"WUW",
|
|
'O',
|
|
Blocks.obsidian,
|
|
'W',
|
|
"plankWood",
|
|
'U',
|
|
RedPowerBase.itemIngotBlue,
|
|
'C',
|
|
Blocks.chest,
|
|
'Q',
|
|
RedPowerBase.itemCopperCoil,
|
|
'B',
|
|
itemBatteryEmpty
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 12),
|
|
new Object[]{
|
|
"NFN",
|
|
"SDS",
|
|
"SRS",
|
|
'N',
|
|
Blocks.netherrack,
|
|
'F',
|
|
Items.flint_and_steel,
|
|
'D',
|
|
new ItemStack(blockMachine, 1, 0),
|
|
'S',
|
|
Blocks.cobblestone,
|
|
'R',
|
|
Items.redstone
|
|
}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachine, 1, 13),
|
|
new Object[]{
|
|
"BIB",
|
|
"CDC",
|
|
"IRI",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'D',
|
|
new ItemStack(blockMachine, 1, 0),
|
|
'C',
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 768),
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'B',
|
|
RedPowerBase.itemIngotBrass
|
|
}
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 14),
|
|
"WBW",
|
|
"WTW",
|
|
"SRS",
|
|
'R',
|
|
Items.redstone,
|
|
'T',
|
|
new ItemStack(blockMachine, 1, 2),
|
|
'W',
|
|
"plankWood",
|
|
'B',
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 2),
|
|
'S',
|
|
Blocks.cobblestone
|
|
);
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 15),
|
|
"WBW",
|
|
"WTW",
|
|
"SRS",
|
|
'R',
|
|
RedPowerBase.itemWaferRed,
|
|
'T',
|
|
new ItemStack(blockMachine, 1, 2),
|
|
'W',
|
|
"plankWood",
|
|
'B',
|
|
new ItemStack(RedPowerBase.blockAppliance, 1, 2),
|
|
'S',
|
|
Blocks.cobblestone
|
|
);
|
|
GameRegistry.addRecipe(
|
|
RedPowerBase.itemCopperCoil, new Object[]{"FBF", "BIB", "FBF", 'F', RedPowerBase.itemFineCopper, 'B', Blocks.iron_bars, 'I', Items.iron_ingot}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
RedPowerBase.itemMotor, new Object[]{"ICI", "ICI", "IBI", 'C', RedPowerBase.itemCopperCoil, 'B', RedPowerBase.itemIngotBlue, 'I', Items.iron_ingot}
|
|
);
|
|
CraftLib.addOreRecipe(new ItemStack(blockFrame, 1), "SSS", "SBS", "SSS", 'S', Items.stick, 'B', "ingotBrass");
|
|
GameRegistry.addShapelessRecipe(
|
|
new ItemStack(blockFrame, 1, 2), new Object[]{new ItemStack(blockFrame, 1), new ItemStack(RedPowerBase.blockMicro, 1, 2048)}
|
|
);
|
|
GameRegistry.addShapelessRecipe(
|
|
new ItemStack(blockFrame, 1, 3), new Object[]{new ItemStack(blockFrame, 1), new ItemStack(RedPowerBase.blockMicro, 1, 2304)}
|
|
);
|
|
GameRegistry.addShapelessRecipe(new ItemStack(blockFrame, 1, 3), new Object[]{new ItemStack(blockFrame, 1, 2), Items.redstone});
|
|
CraftLib.addOreRecipe(
|
|
new ItemStack(blockMachine, 1, 7),
|
|
"III",
|
|
"BMB",
|
|
"IAI",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'A',
|
|
RedPowerBase.itemIngotBlue,
|
|
'B',
|
|
"ingotBrass",
|
|
'M',
|
|
RedPowerBase.itemMotor
|
|
);
|
|
CraftLib.addOreRecipe(new ItemStack(RedPowerBase.blockMicro, 16, 1792), "B B", "BGB", "B B", 'G', Blocks.glass, 'B', "ingotBrass");
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachinePanel, 1, 3), new Object[]{"III", "I I", "IPI", 'P', new ItemStack(RedPowerBase.blockMicro, 1, 1792), 'I', Blocks.iron_bars}
|
|
);
|
|
GameRegistry.addRecipe(
|
|
new ItemStack(blockMachinePanel, 1, 1),
|
|
new Object[]{
|
|
"III",
|
|
"PMP",
|
|
"IAI",
|
|
'I',
|
|
Items.iron_ingot,
|
|
'A',
|
|
RedPowerBase.itemIngotBlue,
|
|
'P',
|
|
new ItemStack(RedPowerBase.blockMicro, 1, 1792),
|
|
'M',
|
|
RedPowerBase.itemMotor
|
|
}
|
|
);
|
|
}
|
|
|
|
public static void initAchievements() {
|
|
AchieveLib.registerAchievement("rpTranspose", -2, 2, new ItemStack(blockMachine, 1, 2), AchievementList.acquireIron);
|
|
AchieveLib.registerAchievement("rpBreaker", -2, 4, new ItemStack(blockMachine, 1, 1), AchievementList.acquireIron);
|
|
AchieveLib.registerAchievement("rpDeploy", -2, 6, new ItemStack(blockMachine, 1, 0), AchievementList.acquireIron);
|
|
AchieveLib.addCraftingAchievement(new ItemStack(blockMachine, 1, 2), "rpTranspose");
|
|
AchieveLib.addCraftingAchievement(new ItemStack(blockMachine, 1, 1), "rpBreaker");
|
|
AchieveLib.addCraftingAchievement(new ItemStack(blockMachine, 1, 0), "rpDeploy");
|
|
AchieveLib.registerAchievement("rpFrames", 4, 4, new ItemStack(blockMachine, 1, 7), "rpIngotBlue");
|
|
AchieveLib.registerAchievement("rpPump", 4, 5, new ItemStack(blockMachinePanel, 1, 1), "rpIngotBlue");
|
|
AchieveLib.addCraftingAchievement(new ItemStack(blockMachine, 1, 7), "rpFrames");
|
|
AchieveLib.addCraftingAchievement(new ItemStack(blockMachinePanel, 1, 1), "rpPump");
|
|
}
|
|
|
|
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int X, int Y, int Z) {
|
|
switch(ID) {
|
|
case 1:
|
|
return new GuiDeploy(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileDeploy.class));
|
|
case 2:
|
|
return new GuiFilter(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileFilter.class));
|
|
case 3:
|
|
return new GuiBlueFurnace(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileBlueFurnace.class));
|
|
case 4:
|
|
return new GuiBufferChest(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileBufferChest.class));
|
|
case 5:
|
|
return new GuiSorter(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileSorter.class));
|
|
case 6:
|
|
return new GuiItemDetect(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileItemDetect.class));
|
|
case 7:
|
|
return new GuiRetriever(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileRetriever.class));
|
|
case 8:
|
|
return new GuiBatteryBox(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileBatteryBox.class));
|
|
case 9:
|
|
return new GuiRegulator(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileRegulator.class));
|
|
case 10:
|
|
return new GuiBlueAlloyFurnace(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileBlueAlloyFurnace.class));
|
|
case 11:
|
|
return new GuiAssemble(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileAssemble.class));
|
|
case 12:
|
|
return new GuiEject(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileEjectBase.class));
|
|
case 13:
|
|
return new GuiEject(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileRelay.class));
|
|
case 14:
|
|
return new GuiChargingBench(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileChargingBench.class));
|
|
case 15:
|
|
return new GuiWindTurbine(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileWindTurbine.class));
|
|
case 16:
|
|
return new GuiManager(player.inventory, CoreLib.getGuiTileEntity(world, X, Y, Z, TileManager.class));
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int X, int Y, int Z) {
|
|
switch(ID) {
|
|
case 1:
|
|
return new ContainerDeploy(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileDeploy.class));
|
|
case 2:
|
|
return new ContainerFilter(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileFilter.class));
|
|
case 3:
|
|
return new ContainerBlueFurnace(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileBlueFurnace.class));
|
|
case 4:
|
|
return new ContainerBufferChest(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileBufferChest.class));
|
|
case 5:
|
|
return new ContainerSorter(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileSorter.class));
|
|
case 6:
|
|
return new ContainerItemDetect(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileItemDetect.class));
|
|
case 7:
|
|
return new ContainerRetriever(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileRetriever.class));
|
|
case 8:
|
|
return new ContainerBatteryBox(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileBatteryBox.class));
|
|
case 9:
|
|
return new ContainerRegulator(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileRegulator.class));
|
|
case 10:
|
|
return new ContainerBlueAlloyFurnace(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileBlueAlloyFurnace.class));
|
|
case 11:
|
|
return new ContainerAssemble(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileAssemble.class));
|
|
case 12:
|
|
return new ContainerEject(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileEjectBase.class));
|
|
case 13:
|
|
return new ContainerEject(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileRelay.class));
|
|
case 14:
|
|
return new ContainerChargingBench(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileChargingBench.class));
|
|
case 15:
|
|
return new ContainerWindTurbine(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileWindTurbine.class));
|
|
case 16:
|
|
return new ContainerManager(player.inventory, CoreLib.getTileEntity(world, X, Y, Z, TileManager.class));
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public void registerRenderers() {
|
|
RenderLib.setRenderer(blockMachine, 0, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 1, RenderBreaker::new);
|
|
RenderLib.setRenderer(blockMachine, 2, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 3, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 4, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 5, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 6, RenderBatteryBox::new);
|
|
RenderLib.setRenderer(blockMachine, 7, RenderMotor::new);
|
|
RenderLib.setRenderer(blockMachine, 8, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 9, RenderWindTurbine::new);
|
|
RenderLib.setRenderer(blockMachine, 10, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 11, RenderThermopile::new);
|
|
RenderLib.setRenderer(blockMachine, 12, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 13, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 14, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine, 15, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine2, 0, RenderMachine::new);
|
|
RenderLib.setRenderer(blockMachine2, 1, RenderMachine::new);
|
|
RenderLib.setRenderer(RedPowerBase.blockAppliance, 1, RenderBlueFurnace::new);
|
|
RenderLib.setRenderer(RedPowerBase.blockAppliance, 2, RenderBufferChest::new);
|
|
RenderLib.setRenderer(RedPowerBase.blockAppliance, 4, RenderBlueAlloyFurnace::new);
|
|
RenderLib.setRenderer(RedPowerBase.blockAppliance, 5, RenderChargingBench::new);
|
|
RenderLib.setHighRenderer(RedPowerBase.blockMicro, 7, RenderPipe::new);
|
|
RenderLib.setHighRenderer(RedPowerBase.blockMicro, 8, RenderTube::new);
|
|
RenderLib.setHighRenderer(RedPowerBase.blockMicro, 9, RenderRedstoneTube::new);
|
|
RenderLib.setHighRenderer(RedPowerBase.blockMicro, 10, RenderTube::new);
|
|
RenderLib.setHighRenderer(RedPowerBase.blockMicro, 11, RenderTube::new);
|
|
RenderLib.setRenderer(blockMachinePanel, 0, RenderSolarPanel::new);
|
|
RenderLib.setRenderer(blockMachinePanel, 1, RenderPump::new);
|
|
RenderLib.setRenderer(blockMachinePanel, 2, RenderAccel::new);
|
|
RenderLib.setRenderer(blockMachinePanel, 3, RenderGrate::new);
|
|
RenderLib.setRenderer(blockMachinePanel, 4, RenderTransformer::new);
|
|
RenderLib.setRenderer(blockFrame, 0, RenderFrame::new);
|
|
RenderLib.setRenderer(blockFrame, 1, RenderFrameMoving::new);
|
|
RenderLib.setRenderer(blockFrame, 2, RenderFrameTube::new);
|
|
RenderLib.setRenderer(blockFrame, 3, RenderFrameRedstoneTube::new);
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileBreaker.class, new RenderBreaker(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileFrame.class, new RenderFrame(blockFrame));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileFrameTube.class, new RenderFrameTube(blockFrame));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileFrameRedstoneTube.class, new RenderFrameRedstoneTube(blockFrame));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileFrameMoving.class, new RenderFrameMoving(blockFrame));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileMachine.class, new RenderMachine(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileTube.class, new RenderTube(RedPowerBase.blockMicro));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileRedstoneTube.class, new RenderRedstoneTube(RedPowerBase.blockMicro));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileMotor.class, new RenderMotor(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileAccel.class, new RenderAccel(blockMachinePanel));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TilePump.class, new RenderPump(blockMachinePanel));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileTransformer.class, new RenderTransformer(blockMachinePanel));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileThermopile.class, new RenderThermopile(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TilePipe.class, new RenderPipe(RedPowerBase.blockMicro));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileWindTurbine.class, new RenderWindTurbine(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileGrate.class, new RenderGrate(blockMachinePanel));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileSolarPanel.class, new RenderSolarPanel(blockMachinePanel));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileBatteryBox.class, new RenderBatteryBox(blockMachine));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileBlueFurnace.class, new RenderBlueFurnace(RedPowerBase.blockAppliance));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileBlueAlloyFurnace.class, new RenderBlueAlloyFurnace(RedPowerBase.blockAppliance));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileChargingBench.class, new RenderChargingBench(RedPowerBase.blockAppliance));
|
|
ClientRegistry.bindTileEntitySpecialRenderer(TileBufferChest.class, new RenderBufferChest(RedPowerBase.blockAppliance));
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
@SubscribeEvent
|
|
public void onTextureStitch(Pre evt) {
|
|
TextureMap map = evt.map;
|
|
if (map.getTextureType() == 0) {
|
|
frameCrossed = map.registerIcon("rpmachine:frameCrossed");
|
|
frameCovered = map.registerIcon("rpmachine:frameCovered");
|
|
framePaneled = map.registerIcon("rpmachine:framePaneled");
|
|
crate = map.registerIcon("rpmachine:crate");
|
|
electronicsBottom = map.registerIcon("rpmachine:electronicsBottom");
|
|
batteryTop = map.registerIcon("rpmachine:batteryTop");
|
|
|
|
for(int i = 0; i < 9; ++i) {
|
|
batterySide[i] = map.registerIcon("rpmachine:batterySide/" + i);
|
|
}
|
|
|
|
retrieverFront = map.registerIcon("rpmachine:retrieverFront");
|
|
retrieverBack = map.registerIcon("rpmachine:retrieverBack");
|
|
retrieverSide = map.registerIcon("rpmachine:retrieverSide");
|
|
retrieverSideOn = map.registerIcon("rpmachine:retrieverSideOn");
|
|
retrieverSideCharged = map.registerIcon("rpmachine:retrieverSideCharged");
|
|
retrieverSideChargedOn = map.registerIcon("rpmachine:retrieverSideChargedOn");
|
|
transposerFront = map.registerIcon("rpmachine:transposerFront");
|
|
transposerSide = map.registerIcon("rpmachine:transposerSide");
|
|
transposerSideOn = map.registerIcon("rpmachine:transposerSideOn");
|
|
filterSide = map.registerIcon("rpmachine:filterSide");
|
|
filterSideOn = map.registerIcon("rpmachine:filterSideOn");
|
|
breakerFront = map.registerIcon("rpmachine:breakerFront");
|
|
breakerFrontOn = map.registerIcon("rpmachine:breakerFrontOn");
|
|
breakerBack = map.registerIcon("rpmachine:breakerBack");
|
|
breakerSide = map.registerIcon("rpmachine:breakerSide");
|
|
breakerSideOn = map.registerIcon("rpmachine:breakerSideOn");
|
|
deployerBack = map.registerIcon("rpmachine:deployerBack");
|
|
deployerFront = map.registerIcon("rpmachine:deployerFront");
|
|
deployerFrontOn = map.registerIcon("rpmachine:deployerFrontOn");
|
|
deployerSide = map.registerIcon("rpmachine:deployerSide");
|
|
deployerSideAlt = map.registerIcon("rpmachine:deployerSideAlt");
|
|
motorBottom = map.registerIcon("rpmachine:motorBottom");
|
|
motorSide = map.registerIcon("rpmachine:motorSide");
|
|
motorFront = map.registerIcon("rpmachine:motorFront");
|
|
motorFrontActive = map.registerIcon("rpmachine:motorFrontActive");
|
|
motorFrontCharged = map.registerIcon("rpmachine:motorFrontCharged");
|
|
motorTop = map.registerIcon("rpmachine:motorTop");
|
|
motorTopActive = map.registerIcon("rpmachine:motorTopActive");
|
|
turbineFront = map.registerIcon("rpmachine:turbineFront");
|
|
turbineSide = map.registerIcon("rpmachine:turbineSide");
|
|
turbineSideAlt = map.registerIcon("rpmachine:turbineSideAlt");
|
|
thermopileFront = map.registerIcon("rpmachine:thermopileFront");
|
|
thermopileSide = map.registerIcon("rpmachine:thermopileSide");
|
|
thermopileTop = map.registerIcon("rpmachine:thermopileTop");
|
|
btFurnaceTop = map.registerIcon("rpmachine:btFurnaceTop");
|
|
btFurnaceSide = map.registerIcon("rpmachine:btFurnaceSide");
|
|
btFurnaceFront = map.registerIcon("rpmachine:btFurnaceFront");
|
|
btFurnaceFrontOn = map.registerIcon("rpmachine:btFurnaceFrontOn");
|
|
btAlloyFurnaceTop = map.registerIcon("rpmachine:btAlloyFurnaceTop");
|
|
btAlloyFurnaceSide = map.registerIcon("rpmachine:btAlloyFurnaceSide");
|
|
btAlloyFurnaceFront = map.registerIcon("rpmachine:btAlloyFurnaceFront");
|
|
btAlloyFurnaceFrontOn = map.registerIcon("rpmachine:btAlloyFurnaceFrontOn");
|
|
btChargerTop = map.registerIcon("rpmachine:btChargerTop");
|
|
btChargerTopOn = map.registerIcon("rpmachine:btChargerTopOn");
|
|
btChargerBottom = map.registerIcon("rpmachine:btChargerBottom");
|
|
btChargerSide = map.registerIcon("rpmachine:btChargerSide");
|
|
btChargerSideOn = map.registerIcon("rpmachine:btChargerSideOn");
|
|
|
|
for(int i = 0; i < 5; ++i) {
|
|
btChargerFront[i] = map.registerIcon("rpmachine:btChargerFront/" + i);
|
|
btChargerFrontPowered[i] = map.registerIcon("rpmachine:btChargerFrontPowered/" + i);
|
|
btChargerFrontActive[i] = map.registerIcon("rpmachine:btChargerFrontActive/" + i);
|
|
}
|
|
|
|
bufferFront = map.registerIcon("rpmachine:bufferFront");
|
|
bufferBack = map.registerIcon("rpmachine:bufferBack");
|
|
bufferSide = map.registerIcon("rpmachine:bufferSide");
|
|
igniterFront = map.registerIcon("rpmachine:igniterFront");
|
|
igniterFrontOn = map.registerIcon("rpmachine:igniterFrontOn");
|
|
igniterSide = map.registerIcon("rpmachine:igniterSide");
|
|
igniterSideAlt = map.registerIcon("rpmachine:igniterSideAlt");
|
|
sorterFront = map.registerIcon("rpmachine:sorterFront");
|
|
sorterBack = map.registerIcon("rpmachine:sorterBack");
|
|
sorterBackCharged = map.registerIcon("rpmachine:sorterBackCharged");
|
|
sorterBackChargedOn = map.registerIcon("rpmachine:sorterBackChargedOn");
|
|
sorterSide = map.registerIcon("rpmachine:sorterSide");
|
|
sorterSideOn = map.registerIcon("rpmachine:sorterSideOn");
|
|
sorterSideCharged = map.registerIcon("rpmachine:sorterSideCharged");
|
|
sorterSideChargedOn = map.registerIcon("rpmachine:sorterSideChargedOn");
|
|
detectorSideAlt = map.registerIcon("rpmachine:detectorSideAlt");
|
|
detectorSideAltOn = map.registerIcon("rpmachine:detectorSideAltOn");
|
|
detectorSide = map.registerIcon("rpmachine:detectorSide");
|
|
detectorSideOn = map.registerIcon("rpmachine:detectorSideOn");
|
|
detectorSideCharged = map.registerIcon("rpmachine:detectorSideCharged");
|
|
detectorSideChargedOn = map.registerIcon("rpmachine:detectorSideChargedOn");
|
|
regulatorFront = map.registerIcon("rpmachine:regulatorFront");
|
|
regulatorBack = map.registerIcon("rpmachine:regulatorBack");
|
|
regulatorSideAlt = map.registerIcon("rpmachine:regulatorSideAlt");
|
|
regulatorSideAltCharged = map.registerIcon("rpmachine:regulatorSideAltCharged");
|
|
regulatorSide = map.registerIcon("rpmachine:regulatorSide");
|
|
regulatorSideOn = map.registerIcon("rpmachine:regulatorSideOn");
|
|
regulatorSideCharged = map.registerIcon("rpmachine:regulatorSideCharged");
|
|
regulatorSideChargedOn = map.registerIcon("rpmachine:regulatorSideChargedOn");
|
|
sortronFront = map.registerIcon("rpmachine:sortronFront");
|
|
sortronBack = map.registerIcon("rpmachine:sortronBack");
|
|
sortronSideAlt = map.registerIcon("rpmachine:sortronSideAlt");
|
|
sortronSideAltCharged = map.registerIcon("rpmachine:sortronSideAltCharged");
|
|
sortronSide = map.registerIcon("rpmachine:sortronSide");
|
|
sortronSideOn = map.registerIcon("rpmachine:sortronSideOn");
|
|
sortronSideCharged = map.registerIcon("rpmachine:sortronSideCharged");
|
|
sortronSideChargedOn = map.registerIcon("rpmachine:sortronSideChargedOn");
|
|
managerFront = map.registerIcon("rpmachine:managerFront");
|
|
managerBack = map.registerIcon("rpmachine:managerBack");
|
|
|
|
for(int i = 0; i < 4; ++i) {
|
|
managerSide[i] = map.registerIcon("rpmachine:managerSide/" + i);
|
|
}
|
|
|
|
for(int i = 0; i < 4; ++i) {
|
|
managerSideCharged[i] = map.registerIcon("rpmachine:managerSideCharged/" + i);
|
|
}
|
|
|
|
assemblerFront = map.registerIcon("rpmachine:assemblerFront");
|
|
assemblerFrontOn = map.registerIcon("rpmachine:assemblerFrontOn");
|
|
assemblerBack = map.registerIcon("rpmachine:assemblerBack");
|
|
assemblerBackOn = map.registerIcon("rpmachine:assemblerBackOn");
|
|
assemblerSide = map.registerIcon("rpmachine:assemblerSide");
|
|
assemblerSideAlt = map.registerIcon("rpmachine:assemblerSideAlt");
|
|
ejectorSide = map.registerIcon("rpmachine:ejectorSide");
|
|
ejectorSideOn = map.registerIcon("rpmachine:ejectorSideOn");
|
|
relaySide = map.registerIcon("rpmachine:relaySide");
|
|
relaySideOn = map.registerIcon("rpmachine:relaySideOn");
|
|
relaySideAlt = map.registerIcon("rpmachine:relaySideAlt");
|
|
pipeSide = map.registerIcon("rpmachine:pipeSide");
|
|
pipeFace = map.registerIcon("rpmachine:pipeFace");
|
|
pipeFlanges = map.registerIcon("rpmachine:pipeFlanges");
|
|
baseTubeSide = map.registerIcon("rpmachine:tubeSide");
|
|
baseTubeFace = map.registerIcon("rpmachine:tubeFace");
|
|
baseTubeSideColor = map.registerIcon("rpmachine:tubeSideColor");
|
|
baseTubeFaceColor = map.registerIcon("rpmachine:tubeFaceColor");
|
|
|
|
for(int i = 0; i < 4; ++i) {
|
|
redstoneTubeSide[i] = map.registerIcon("rpmachine:redstoneTubeSide/" + i);
|
|
redstoneTubeFace[i] = map.registerIcon("rpmachine:redstoneTubeFace/" + i);
|
|
}
|
|
|
|
restrictTubeSide = map.registerIcon("rpmachine:restrictionTubeSide");
|
|
restrictTubeFace = map.registerIcon("rpmachine:restrictionTubeFace");
|
|
restrictTubeSideColor = map.registerIcon("rpmachine:restrictionTubeSideColor");
|
|
restrictTubeFaceColor = map.registerIcon("rpmachine:restrictionTubeFaceColor");
|
|
magTubeSide = map.registerIcon("rpmachine:magneticTubeSide");
|
|
magTubeRing = map.registerIcon("rpmachine:magneticTubeRing");
|
|
magTubeFace = map.registerIcon("rpmachine:magneticTubeFace");
|
|
magTubeSideNR = map.registerIcon("rpmachine:magneticTubeSideNR");
|
|
magTubeFaceNR = map.registerIcon("rpmachine:magneticTubeFaceNR");
|
|
tubeItemOverlay = map.registerIcon("rpmachine:tubeItemOverlay");
|
|
solarPanelTop = map.registerIcon("rpmachine:solarPanelTop");
|
|
solarPanelSide = map.registerIcon("rpmachine:solarPanelSide");
|
|
grateSide = map.registerIcon("rpmachine:grateSide");
|
|
grateMossySide = map.registerIcon("rpmachine:grateMossySide");
|
|
grateBack = map.registerIcon("rpmachine:grateBack");
|
|
grateEmptyBack = map.registerIcon("rpmachine:grateEmptyBack");
|
|
}
|
|
|
|
}
|
|
}
|