diff options
Diffstat (limited to 'src/Java/miscutil')
21 files changed, 889 insertions, 30 deletions
diff --git a/src/Java/miscutil/core/block/ModBlocks.java b/src/Java/miscutil/core/block/ModBlocks.java index 589f8f42d4..9893430b69 100644 --- a/src/Java/miscutil/core/block/ModBlocks.java +++ b/src/Java/miscutil/core/block/ModBlocks.java @@ -1,8 +1,9 @@ package miscutil.core.block; +import miscutil.core.block.base.BasicBlock; import miscutil.core.block.fluids.BlocktestFluid; import miscutil.core.block.heliumgen.block.HeliumGenerator; -import miscutil.core.block.heliumgen.tileentity.TileEntityHeliumGenerator; +import miscutil.core.block.machine.Machine_NHG; import miscutil.core.lib.CORE; import miscutil.core.util.Utils; import miscutil.gregtech.common.blocks.GregtechMetaCasingBlocks; @@ -21,6 +22,7 @@ public final class ModBlocks { public static Block blockGriefSaver; public static Block blockCasingsMisc; public static Block blockHeliumGenerator; + public static Block blockNHG; @@ -79,7 +81,8 @@ public final class ModBlocks { testFluid.setUnlocalizedName(testFluidBlock.getUnlocalizedName()); blockHeliumGenerator = GameRegistry.registerBlock(new HeliumGenerator(), "Helium_Collector"); - GameRegistry.registerTileEntity(TileEntityHeliumGenerator.class, "Helium"); + blockNHG = GameRegistry.registerBlock(new Machine_NHG("blockNuclearFueledHeliumGenerator"), "blockNuclearFueledHeliumGenerator"); + //WIP TODO //GameRegistry.registerBlock(blockGriefSaver, "blockGriefSaver"); diff --git a/src/Java/miscutil/core/block/AdvancedBlock.java b/src/Java/miscutil/core/block/base/AdvancedBlock.java index 3ad2454be4..78e8c3cbe0 100644 --- a/src/Java/miscutil/core/block/AdvancedBlock.java +++ b/src/Java/miscutil/core/block/base/AdvancedBlock.java @@ -1,4 +1,4 @@ -package miscutil.core.block; +package miscutil.core.block.base; import miscutil.core.lib.CORE; import net.minecraft.block.Block; diff --git a/src/Java/miscutil/core/block/BasicBlock.java b/src/Java/miscutil/core/block/base/BasicBlock.java index 061e66d9c5..4e5fd13df8 100644 --- a/src/Java/miscutil/core/block/BasicBlock.java +++ b/src/Java/miscutil/core/block/base/BasicBlock.java @@ -1,4 +1,4 @@ -package miscutil.core.block; +package miscutil.core.block.base; import miscutil.core.creative.AddToCreativeTab; import miscutil.core.lib.CORE; @@ -7,7 +7,7 @@ import net.minecraft.block.material.Material; public class BasicBlock extends Block { - protected BasicBlock(String unlocalizedName, Material material) { + public BasicBlock(String unlocalizedName, Material material) { super(material); this.setBlockName(unlocalizedName); this.setBlockTextureName(CORE.MODID + ":" + unlocalizedName); diff --git a/src/Java/miscutil/core/block/heliumgen/block/HeliumGenerator.java b/src/Java/miscutil/core/block/heliumgen/block/HeliumGenerator.java index 0a0253a384..f424097240 100644 --- a/src/Java/miscutil/core/block/heliumgen/block/HeliumGenerator.java +++ b/src/Java/miscutil/core/block/heliumgen/block/HeliumGenerator.java @@ -119,7 +119,10 @@ public class HeliumGenerator extends BlockContainer { if (collector != null) { - ItemStack itemstack = collector.getStackInSlot(0); + int i = 0; + for (i = 0; i < collector.getSizeInventory(); i++){ + + ItemStack itemstack = collector.getStackInSlot(i); if (itemstack != null) { @@ -154,6 +157,7 @@ public class HeliumGenerator extends BlockContainer { world.func_147453_f(x, y, z, block); } + } super.breakBlock(world, x, y, z, block, wut); } diff --git a/src/Java/miscutil/core/block/heliumgen/container/ContainerHeliumGenerator.java b/src/Java/miscutil/core/block/heliumgen/container/ContainerHeliumGenerator.java index d7e612b9f6..7de3efd4c6 100644 --- a/src/Java/miscutil/core/block/heliumgen/container/ContainerHeliumGenerator.java +++ b/src/Java/miscutil/core/block/heliumgen/container/ContainerHeliumGenerator.java @@ -6,7 +6,6 @@ import ic2.core.slot.SlotInvSlot; import java.util.List; import miscutil.core.block.heliumgen.tileentity.TileEntityHeliumGenerator; -import miscutil.core.util.Utils; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Slot; import net.minecraft.inventory.SlotFurnace; @@ -19,7 +18,7 @@ extends ContainerBase<TileEntityHeliumGenerator> public ContainerHeliumGenerator(InventoryPlayer player, TileEntityHeliumGenerator machine) { super(machine); - Utils.LOG_WARNING("containerHeliumGenerator"); + //Utils.LOG_WARNING("containerHeliumGenerator"); short sr = machine.getReactorSize(); this.addSlotToContainer(new SlotFurnace(player.player, machine, 2, 80, 35)); this.size = sr; diff --git a/src/Java/miscutil/core/block/heliumgen/gui/GUIHeliumGenerator.java b/src/Java/miscutil/core/block/heliumgen/gui/GUIHeliumGenerator.java index 6939d1d8f8..309a7b5fba 100644 --- a/src/Java/miscutil/core/block/heliumgen/gui/GUIHeliumGenerator.java +++ b/src/Java/miscutil/core/block/heliumgen/gui/GUIHeliumGenerator.java @@ -29,7 +29,7 @@ public class GUIHeliumGenerator extends GuiContainer @Override protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_) { - String s = StatCollector.translateToLocal("container.helium_collector"); + String s = StatCollector.translateToLocal("Helium Collector"); this.fontRendererObj.drawString(s, this.xSize / 2 - this.fontRendererObj.getStringWidth(s) / 2, 6, 4210752); this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); diff --git a/src/Java/miscutil/core/block/heliumgen/tileentity/TileEntityHeliumGenerator.java b/src/Java/miscutil/core/block/heliumgen/tileentity/TileEntityHeliumGenerator.java index 88fc44339a..75b1de7f5c 100644 --- a/src/Java/miscutil/core/block/heliumgen/tileentity/TileEntityHeliumGenerator.java +++ b/src/Java/miscutil/core/block/heliumgen/tileentity/TileEntityHeliumGenerator.java @@ -31,6 +31,7 @@ import net.minecraft.inventory.IInventory; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; import net.minecraft.network.Packet; import net.minecraft.network.play.server.S35PacketUpdateTileEntity; import net.minecraft.tileentity.TileEntity; @@ -100,7 +101,13 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II { super.readFromNBT(nbttagcompound); - this.heliumStack = ItemStack.loadItemStackFromNBT(nbttagcompound.getCompoundTag("Helium")); + //this.heliumStack = ItemStack.loadItemStackFromNBT(nbttagcompound.getCompoundTag("Helium")); + NBTTagList list = nbttagcompound.getTagList("Items", 10); + for (int i = 0; i < list.tagCount(); ++i) { + NBTTagCompound stackTag = list.getCompoundTagAt(i); + int slot = stackTag.getByte("Slot") & 255; + this.setInventorySlotContents(slot, ItemStack.loadItemStackFromNBT(stackTag)); + } this.progress = nbttagcompound.getInteger("Progress"); this.facing = nbttagcompound.getShort("Facing"); this.heat = nbttagcompound.getInteger("heat"); @@ -118,13 +125,23 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II nbttagcompound.setInteger("heat", this.heat); nbttagcompound.setShort("output", (short)(int)getReactorEnergyOutput()); nbttagcompound.setBoolean("active", this.active); - if(heliumStack != null) { + /*if(heliumStack != null) { NBTTagCompound produce = new NBTTagCompound(); heliumStack.writeToNBT(produce); nbttagcompound.setTag("Helium", produce); } else - nbttagcompound.removeTag("Helium"); + nbttagcompound.removeTag("Helium");*/ + NBTTagList list = new NBTTagList(); + for (int i = 0; i < this.getSizeInventory(); ++i) { + if (this.getStackInSlot(i) != null) { + NBTTagCompound stackTag = new NBTTagCompound(); + stackTag.setByte("Slot", (byte) i); + this.getStackInSlot(i).writeToNBT(stackTag); + list.appendTag(stackTag); + } + } + nbttagcompound.setTag("Items", list); } @@ -227,7 +244,7 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II public float output = 0.0F; public int updateTicker; public int heat = 5000; - public int maxHeat = 10000; + public int maxHeat = 100000; public float hem = 1.0F; private int EmitHeatbuffer = 0; public int EmitHeat = 0; @@ -340,7 +357,7 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II public boolean isUsefulItem(ItemStack stack, boolean forInsertion) { - Utils.LOG_WARNING("isUsefulItem"); + //Utils.LOG_WARNING("isUsefulItem"); Item item = stack.getItem(); if ((forInsertion) && (this.fluidcoolreactor) && ((item instanceof ItemReactorHeatStorage)) && @@ -356,7 +373,7 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II public boolean calculateHeatEffects() { Utils.LOG_WARNING("calculateHeatEffects"); - if ((this.heat < 4000) || (!IC2.platform.isSimulating()) || (ConfigUtil.getFloat(MainConfig.get(), "protection/reactorExplosionPowerLimit") <= 0.0F)) { + if ((this.heat < 8000) || (!IC2.platform.isSimulating()) || (ConfigUtil.getFloat(MainConfig.get(), "protection/reactorExplosionPowerLimit") <= 0.0F)) { return false; } float power = this.heat / this.maxHeat; @@ -441,8 +458,8 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II { Utils.LOG_WARNING("processChambers"); int size = getReactorSize(); - for (int pass = 0; pass < 2; pass++) { - for (int y = 0; y < 6; y++) { + for (int pass = 0; pass < 6; pass++) { + for (int y = 0; y < 3; y++) { for (int x = 0; x < size; x++) { ItemStack stack = this.reactorSlot.get(x, y); @@ -560,7 +577,7 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II public TileEntityHeliumGenerator() { this.updateTicker = IC2.random.nextInt(getTickRate()); - this.reactorSlot = new InvSlotRadiation(this, "collector", 0, 54); //TODO + this.reactorSlot = new InvSlotRadiation(this, "helium_collector", 0, 54); //TODO } @Override @@ -579,6 +596,7 @@ public class TileEntityHeliumGenerator extends TileEntityInventory implements II { Utils.LOG_WARNING("receiveRedstone"); if ((this.worldObj.isBlockIndirectlyGettingPowered(this.xCoord, this.yCoord, this.zCoord)) || (this.redstone)) { + decrStackSize(-1, 1); return true; } return false; diff --git a/src/Java/miscutil/core/block/machine/Machine_NHG.java b/src/Java/miscutil/core/block/machine/Machine_NHG.java new file mode 100644 index 0000000000..1738469fd7 --- /dev/null +++ b/src/Java/miscutil/core/block/machine/Machine_NHG.java @@ -0,0 +1,82 @@ +package miscutil.core.block.machine; + +import java.util.ArrayList; + +import miscutil.MiscUtils; +import miscutil.core.creative.AddToCreativeTab; +import miscutil.core.lib.CORE; +import miscutil.core.tileentities.TileEntityNHG; +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import scala.util.Random; + +public class Machine_NHG extends BlockContainer +{ + private static final String name = "Nuclear Fueled Helium Generator"; + + private final Random rand = new Random(); + + public Machine_NHG(String unlocalizedName) + { + super(Material.iron); + //GameRegistry.registerBlock(this, unlocalizedName); + this.setBlockName(unlocalizedName); + this.setBlockTextureName(CORE.MODID + ":" + unlocalizedName); + this.setCreativeTab(AddToCreativeTab.tabMachines); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float lx, float ly, float lz) + { + if (world.isRemote) return true; + + TileEntity te = world.getTileEntity(x, y, z); + if (te != null && te instanceof TileEntityNHG) + { + player.openGui(MiscUtils.instance, 0, world, x, y, z); + return true; + } + return false; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block block, int par6) + { + if (world.isRemote) return; + + ArrayList drops = new ArrayList(); + + TileEntity teRaw = world.getTileEntity(x, y, z); + + if (teRaw != null && teRaw instanceof TileEntityNHG) + { + TileEntityNHG te = (TileEntityNHG) teRaw; + + for (int i = 0; i < te.getSizeInventory(); i++) + { + ItemStack stack = te.getStackInSlot(i); + + if (stack != null) drops.add(stack.copy()); + } + } + + for (int i = 0;i < drops.size();i++) + { + EntityItem item = new EntityItem(world, x + 0.5, y + 0.5, z + 0.5, (ItemStack) drops.get(i)); + item.setVelocity((rand.nextDouble() - 0.5) * 0.25, rand.nextDouble() * 0.5 * 0.25, (rand.nextDouble() - 0.5) * 0.25); + world.spawnEntityInWorld(item); + } + } + + @Override + public TileEntity createNewTileEntity(World world, int par2) + { + return new TileEntityNHG(); + } +}
\ No newline at end of file diff --git a/src/Java/miscutil/core/common/CommonProxy.java b/src/Java/miscutil/core/common/CommonProxy.java index 3af77bc742..26c5775290 100644 --- a/src/Java/miscutil/core/common/CommonProxy.java +++ b/src/Java/miscutil/core/common/CommonProxy.java @@ -84,10 +84,6 @@ public class CommonProxy { public void registerTileEntities(){ ModTileEntities.init(); - //GameRegistry.registerTileEntity(TileEntityBloodSteelChest.class, "tileEntityBloodSteelChest"); - //GameRegistry.registerTileEntity(TileEntityBloodSteelFurnace.class, "tileEntityBloodSteelFurnace"); - //GameRegistry.registerTileEntity(TileEntityBloodSteelChest.class, CORE.MODID); - //GameRegistry.registerTileEntity(TileEntityArcaneInfuser.class, "TileEntityArcaneInfuser"); } public void registerRenderThings() { diff --git a/src/Java/miscutil/core/container/Container_NHG.java b/src/Java/miscutil/core/container/Container_NHG.java new file mode 100644 index 0000000000..8baed3f5bd --- /dev/null +++ b/src/Java/miscutil/core/container/Container_NHG.java @@ -0,0 +1,104 @@ +package miscutil.core.container; + +import miscutil.core.tileentities.TileEntityNHG; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotFurnace; +import net.minecraft.item.ItemStack; + +public class Container_NHG extends Container +{ + private TileEntityNHG te; + + public static final int INPUT_1 = 0, INPUT_2 = 1, INPUT_3 = 2, + INPUT_4 = 3, INPUT_5 = 4, INPUT_6 = 5, + INPUT_7 = 6, INPUT_8 = 7, INPUT_9 = 8, + INPUT_10 = 9, INPUT_11 = 10, INPUT_12 = 11, + INPUT_13 = 12, INPUT_14 = 13, INPUT_15 = 14, + INPUT_16 = 15, INPUT_17 = 16, INPUT_18 = 17, + OUTPUT = 18; + + private int slotID = 0; + + public Container_NHG(TileEntityNHG te, EntityPlayer player) + { + this.te = te; + + + //Fuel Rods A + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + addSlotToContainer(new Slot(te, slotID++, 8 + j * 18, 17 + i * 18)); + } + } + //Fuel Rods B + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 3; j++) + { + addSlotToContainer(new Slot(te, slotID++, 116 + j * 18, 17 + i * 18)); + } + } + + //Output + addSlotToContainer(new SlotFurnace(player, te, OUTPUT, 80, 53)); + + //Inventory + for (int i = 0; i < 3; i++) + { + for (int j = 0; j < 9; j++) + { + addSlotToContainer(new Slot(player.inventory, j + i * 9 + 9, 8 + j * 18, 84 + i * 18)); + } + } + // Hotbar + for (int i = 0; i < 9; i++) + { + addSlotToContainer(new Slot(player.inventory, i, 8 + i * 18, 142)); + } + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer player, int slotRaw) + { + ItemStack stack = null; + Slot slot = (Slot)inventorySlots.get(slotRaw); + + if (slot != null && slot.getHasStack()) + { + ItemStack stackInSlot = slot.getStack(); + stack = stackInSlot.copy(); + + if (slotRaw < 3 * 9) + { + if (!mergeItemStack(stackInSlot, 3 * 9, inventorySlots.size(), true)) + { + return null; + } + } + else if (!mergeItemStack(stackInSlot, 0, 3 * 9, false)) + { + return null; + } + + if (stackInSlot.stackSize == 0) + { + slot.putStack((ItemStack)null); + } + else + { + slot.onSlotChanged(); + } + } + return stack; + } + + @Override + public boolean canInteractWith(EntityPlayer player) + { + return te.isUseableByPlayer(player); + } +}
\ No newline at end of file diff --git a/src/Java/miscutil/core/item/EntityTeleportFX.java b/src/Java/miscutil/core/entity/EntityTeleportFX.java index d67ee77968..18867c20cc 100644 --- a/src/Java/miscutil/core/item/EntityTeleportFX.java +++ b/src/Java/miscutil/core/entity/EntityTeleportFX.java @@ -1,4 +1,4 @@ -package miscutil.core.item; +package miscutil.core.entity; import net.minecraft.entity.Entity; import net.minecraft.entity.item.EntityItem; diff --git a/src/Java/miscutil/core/gui/ModGUI.java b/src/Java/miscutil/core/gui/ModGUI.java index b9ecf00134..259270d224 100644 --- a/src/Java/miscutil/core/gui/ModGUI.java +++ b/src/Java/miscutil/core/gui/ModGUI.java @@ -4,6 +4,7 @@ import miscutil.MiscUtils; import miscutil.core.block.heliumgen.container.ContainerHeliumGenerator; import miscutil.core.block.heliumgen.gui.GUIHeliumGenerator; import miscutil.core.block.heliumgen.tileentity.TileEntityHeliumGenerator; +import miscutil.core.handler.GuiHandler; import miscutil.core.util.Utils; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.world.World; @@ -16,7 +17,7 @@ public class ModGUI { public static void init(){ Utils.LOG_INFO("Registering GUIs."); - NetworkRegistry.INSTANCE.registerGuiHandler(MiscUtils.instance, new GUI_HANDLER()); + NetworkRegistry.INSTANCE.registerGuiHandler(MiscUtils.instance, new GuiHandler()); //Register GuiHandler //NetworkRegistry.INSTANCE.registerGuiHandler(MiscUtils.instance, new GuiHandler()); } diff --git a/src/Java/miscutil/core/gui/machine/GUI_NHG.java b/src/Java/miscutil/core/gui/machine/GUI_NHG.java new file mode 100644 index 0000000000..6078a5ad00 --- /dev/null +++ b/src/Java/miscutil/core/gui/machine/GUI_NHG.java @@ -0,0 +1,48 @@ +package miscutil.core.gui.machine; + +import miscutil.core.container.Container_NHG; +import miscutil.core.lib.CORE; +import miscutil.core.tileentities.TileEntityNHG; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +public class GUI_NHG extends GuiContainer +{ + private ResourceLocation texture = new ResourceLocation(CORE.MODID, "textures/gui/helium_collector_gui_12.png"); + + private InventoryPlayer inventory; + private TileEntityNHG te; + + public GUI_NHG(TileEntityNHG te, EntityPlayer player) + { + super(new Container_NHG(te, player)); + inventory = player.inventory; + this.te = te; + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + Minecraft.getMinecraft().renderEngine.bindTexture(texture); + + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + + int x = (width - xSize) / 2; + int y = (height - ySize) / 2; + + drawTexturedModalRect(x, y, 0, 0, xSize, ySize); + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) + { + fontRendererObj.drawString(I18n.format(te.getInventoryName()), (xSize / 2) - (fontRendererObj.getStringWidth(I18n.format(te.getInventoryName())) / 2), 6, 4210752, false); + fontRendererObj.drawString(I18n.format(inventory.getInventoryName()), 8, ySize - 96 + 2, 4210752); + } +}
\ No newline at end of file diff --git a/src/Java/miscutil/core/handler/GuiHandler.java b/src/Java/miscutil/core/handler/GuiHandler.java index 951b697aab..67200c6cf3 100644 --- a/src/Java/miscutil/core/handler/GuiHandler.java +++ b/src/Java/miscutil/core/handler/GuiHandler.java @@ -1,36 +1,53 @@ package miscutil.core.handler; +import miscutil.core.container.Container_NHG; +import miscutil.core.gui.machine.GUI_NHG; +import miscutil.core.tileentities.TileEntityNHG; import miscutil.core.util.Utils; import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; import cpw.mods.fml.common.network.IGuiHandler; public class GuiHandler implements IGuiHandler { - private static final int GUI1 = 0; //Nothing Yet + private static final int GUI1 = 0; //Nuclear Helium Gen. private static final int GUI2 = 1; //Energy Buffer @Override //ContainerModTileEntity public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { - if (ID == GUI1){} - //return new GUI_Battery_Buffer(); + TileEntity te = world.getTileEntity(x, y, z); + if (te != null){ + if (ID == GUI1){ + return new Container_NHG((TileEntityNHG)te, player); + } + else if (ID == GUI2){ + + } + + + + } return null; } @Override //GuiModTileEntity public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { Utils.LOG_WARNING("getClientGuiElement Called by: "+player+", in world: "+player.dimension+" at x:"+x+", y:"+y+", z:"+z+"."); + TileEntity te = world.getTileEntity(x, y, z); + if (te != null){ if (ID == GUI1){ - Utils.LOG_WARNING("Opening Gui with Id: "+ID); - //return new GUI_Battery_Buffer(); + Utils.LOG_WARNING("Opening Gui with Id: "+ID+" NHG"); + return new GUI_NHG((TileEntityNHG) te, player); } else if (ID == GUI2){ Utils.LOG_WARNING("Opening Gui with Id: "+ID+" Energy Buffer"); //return new GUI_Bat_Buf(); } + } return null; } diff --git a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java index 9169249136..524adfc97f 100644 --- a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java +++ b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java @@ -59,7 +59,7 @@ public class PickaxeBlockBreakEventHandler { @SubscribeEvent public void onPlayerInteraction(PlayerInteractEvent aEvent) { if (aEvent.entityPlayer != null && aEvent.entityPlayer.worldObj != null && aEvent.action != null && aEvent.world.provider != null && !aEvent.entityPlayer.worldObj.isRemote && aEvent.action != null && aEvent.action != PlayerInteractEvent.Action.RIGHT_CLICK_AIR) { - Utils.LOG_ERROR("Test"); + //Utils.LOG_ERROR("Test"); } } } diff --git a/src/Java/miscutil/core/item/ModItems.java b/src/Java/miscutil/core/item/ModItems.java index e704ac0365..fbec6a59a3 100644 --- a/src/Java/miscutil/core/item/ModItems.java +++ b/src/Java/miscutil/core/item/ModItems.java @@ -4,6 +4,7 @@ import static miscutil.core.lib.CORE.LOAD_ALL_CONTENT; import miscutil.core.creative.AddToCreativeTab; import miscutil.core.item.effects.RarityUncommon; import miscutil.core.item.general.BufferCore; +import miscutil.core.item.general.fuelrods.FuelRod_Base; import miscutil.core.item.tool.misc.SandstoneHammer; import miscutil.core.item.tool.staballoy.StaballoyAxe; import miscutil.core.item.tool.staballoy.StaballoyPickaxe; @@ -98,6 +99,12 @@ Gold Tool: 22*/ public static Item itemPlateBatteryAlloy; public static Item itemHeliumBlob; public static Item item_PLEASE_FACTOR_ME_4; + + public static Item FuelRod_Empty; + public static Item FuelRod_Thorium; + public static Item FuelRod_Uranium; + public static Item FuelRod_Plutonium; + //@SuppressWarnings("unused") public static final void init(){ @@ -209,6 +216,23 @@ Gold Tool: 22*/ else { Utils.LOG_WARNING("rfTools not Found - Skipping Resources."); } + //IC2 Exp + if (LoadedMods.IndustrialCraft2|| LOAD_ALL_CONTENT){ + Utils.LOG_INFO("IndustrialCraft2 Found - Loading Resources."); + //Item Init + FuelRod_Empty = new FuelRod_Base("itemFuelRod_Empty", "Empty", 0, 1000); + FuelRod_Thorium = new FuelRod_Base("itemFuelRod_Thorium", "Thorium", 1000, 1000); + FuelRod_Uranium = new FuelRod_Base("itemFuelRod_Uranium", "Uranium", 2500, 2500); + FuelRod_Plutonium = new FuelRod_Base("itemFuelRod_Plutonium", "Plutonium", 5000, 5000); + //Registry + GameRegistry.registerItem(FuelRod_Empty, "itemFuelRod_Empty"); + GameRegistry.registerItem(FuelRod_Thorium, "itemFuelRod_Thorium"); + GameRegistry.registerItem(FuelRod_Uranium, "itemFuelRod_Uranium"); + GameRegistry.registerItem(FuelRod_Plutonium, "itemFuelRod_Plutonium"); + } + else { + Utils.LOG_WARNING("IndustrialCraft2 not Found - Skipping Resources."); + } /* * Misc Items */ diff --git a/src/Java/miscutil/core/item/general/NuclearFuelRodBase.java b/src/Java/miscutil/core/item/general/NuclearFuelRodBase.java new file mode 100644 index 0000000000..7de0f93fab --- /dev/null +++ b/src/Java/miscutil/core/item/general/NuclearFuelRodBase.java @@ -0,0 +1,210 @@ +package miscutil.core.item.general; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +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.util.MovingObjectPosition; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.player.FillBucketEvent; +import cpw.mods.fml.common.eventhandler.Event; + +public class NuclearFuelRodBase extends Item +{ + /** field for checking if the bucket has been filled. */ + private Block isFull; + public NuclearFuelRodBase(Block p_i45331_1_) + { + this.maxStackSize = 1; + this.isFull = p_i45331_1_; + this.setCreativeTab(CreativeTabs.tabMisc); + } + + /** + * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer + */ + @Override + public ItemStack onItemRightClick(ItemStack p_77659_1_, World p_77659_2_, EntityPlayer p_77659_3_) + { + boolean flag = this.isFull == Blocks.air; + MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(p_77659_2_, p_77659_3_, flag); + + if (movingobjectposition == null) + { + return p_77659_1_; + } + FillBucketEvent event = new FillBucketEvent(p_77659_3_, p_77659_1_, p_77659_2_, movingobjectposition); + if (MinecraftForge.EVENT_BUS.post(event)) + { + return p_77659_1_; + } + + if (event.getResult() == Event.Result.ALLOW) + { + if (p_77659_3_.capabilities.isCreativeMode) + { + return p_77659_1_; + } + + if (--p_77659_1_.stackSize <= 0) + { + return event.result; + } + + if (!p_77659_3_.inventory.addItemStackToInventory(event.result)) + { + p_77659_3_.dropPlayerItemWithRandomChoice(event.result, false); + } + + return p_77659_1_; + } + if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) + { + int i = movingobjectposition.blockX; + int j = movingobjectposition.blockY; + int k = movingobjectposition.blockZ; + + if (!p_77659_2_.canMineBlock(p_77659_3_, i, j, k)) + { + return p_77659_1_; + } + + if (flag) + { + if (!p_77659_3_.canPlayerEdit(i, j, k, movingobjectposition.sideHit, p_77659_1_)) + { + return p_77659_1_; + } + + Material material = p_77659_2_.getBlock(i, j, k).getMaterial(); + int l = p_77659_2_.getBlockMetadata(i, j, k); + + if (material == Material.water && l == 0) + { + p_77659_2_.setBlockToAir(i, j, k); + return this.func_150910_a(p_77659_1_, p_77659_3_, Items.water_bucket); + } + + if (material == Material.lava && l == 0) + { + p_77659_2_.setBlockToAir(i, j, k); + return this.func_150910_a(p_77659_1_, p_77659_3_, Items.lava_bucket); + } + } + else + { + if (this.isFull == Blocks.air) + { + return new ItemStack(Items.bucket); + } + + if (movingobjectposition.sideHit == 0) + { + --j; + } + + if (movingobjectposition.sideHit == 1) + { + ++j; + } + + if (movingobjectposition.sideHit == 2) + { + --k; + } + + if (movingobjectposition.sideHit == 3) + { + ++k; + } + + if (movingobjectposition.sideHit == 4) + { + --i; + } + + if (movingobjectposition.sideHit == 5) + { + ++i; + } + + if (!p_77659_3_.canPlayerEdit(i, j, k, movingobjectposition.sideHit, p_77659_1_)) + { + return p_77659_1_; + } + + if (this.tryPlaceContainedLiquid(p_77659_2_, i, j, k) && !p_77659_3_.capabilities.isCreativeMode) + { + return new ItemStack(Items.bucket); + } + } + } + + return p_77659_1_; + } + + @SuppressWarnings("static-method") + private ItemStack func_150910_a(ItemStack p_150910_1_, EntityPlayer p_150910_2_, Item p_150910_3_) + { + if (p_150910_2_.capabilities.isCreativeMode) + { + return p_150910_1_; + } + else if (--p_150910_1_.stackSize <= 0) + { + return new ItemStack(p_150910_3_); + } + else + { + if (!p_150910_2_.inventory.addItemStackToInventory(new ItemStack(p_150910_3_))) + { + p_150910_2_.dropPlayerItemWithRandomChoice(new ItemStack(p_150910_3_, 1, 0), false); + } + + return p_150910_1_; + } + } + + /** + * Attempts to place the liquid contained inside the bucket. + */ + public boolean tryPlaceContainedLiquid(World p_77875_1_, int p_77875_2_, int p_77875_3_, int p_77875_4_) + { + if (this.isFull == Blocks.air) + { + return false; + } + Material material = p_77875_1_.getBlock(p_77875_2_, p_77875_3_, p_77875_4_).getMaterial(); + boolean flag = !material.isSolid(); + + if (!p_77875_1_.isAirBlock(p_77875_2_, p_77875_3_, p_77875_4_) && !flag) + { + return false; + } + if (p_77875_1_.provider.isHellWorld && this.isFull == Blocks.flowing_water) + { + p_77875_1_.playSoundEffect((double)((float)p_77875_2_ + 0.5F), (double)((float)p_77875_3_ + 0.5F), (double)((float)p_77875_4_ + 0.5F), "random.fizz", 0.5F, 2.6F + (p_77875_1_.rand.nextFloat() - p_77875_1_.rand.nextFloat()) * 0.8F); + + for (int l = 0; l < 8; ++l) + { + p_77875_1_.spawnParticle("largesmoke", (double)p_77875_2_ + Math.random(), (double)p_77875_3_ + Math.random(), (double)p_77875_4_ + Math.random(), 0.0D, 0.0D, 0.0D); + } + } + else + { + if (!p_77875_1_.isRemote && flag && !material.isLiquid()) + { + p_77875_1_.func_147480_a(p_77875_2_, p_77875_3_, p_77875_4_, true); + } + + p_77875_1_.setBlock(p_77875_2_, p_77875_3_, p_77875_4_, this.isFull, 0, 3); + } + + return true; + } +}
\ No newline at end of file diff --git a/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Base.java b/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Base.java new file mode 100644 index 0000000000..aedf91f66a --- /dev/null +++ b/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Base.java @@ -0,0 +1,150 @@ +package miscutil.core.item.general.fuelrods; + +import java.util.List; + +import miscutil.core.creative.AddToCreativeTab; +import miscutil.core.lib.CORE; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; + +public class FuelRod_Base extends Item{ + + public int fuelRemaining = 0; + public int maximumFuel = 0; + public String fuelType = ""; + public float heat = 0; + public float maxHeat = 5000; + private ItemStack thisStack = null; + private int internalClock = 0; + + public FuelRod_Base(String unlocalizedName, String type, int fuelLeft, int maxFuel) { + this.setUnlocalizedName(unlocalizedName); + this.setTextureName(CORE.MODID + ":" + unlocalizedName); + this.setMaxStackSize(1); + this.setMaxDamage(maxFuel); + this.maximumFuel = maxFuel; + this.fuelRemaining = fuelLeft; + this.fuelType = type; + this.setCreativeTab(AddToCreativeTab.tabMachines); + } + @Override + public boolean onEntityItemUpdate(EntityItem entityItem) { + if (internalClock <= 200){ + internalClock++; + } + else { + if (heat < maxHeat){ + heat++; + } + if (fuelRemaining <= maximumFuel){ + fuelRemaining--; + } + internalClock = 0; + } + return super.onEntityItemUpdate(entityItem); + } + @Override + public void setDamage(ItemStack stack, int damage) { + this.heat=heat+5; + super.setDamage(stack, damage); + } + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) { + thisStack = stack; + String tempHeat = String.valueOf(heat); + String tempFuel = String.valueOf(fuelRemaining); + String formattedType = EnumChatFormatting.DARK_RED+fuelType+EnumChatFormatting.GRAY; + String formattedHeat = EnumChatFormatting.RED+tempHeat+EnumChatFormatting.GRAY; + String formattedFuelLeft = tempFuel+EnumChatFormatting.GRAY; + + int tempMax = maximumFuel; + float tempCurrentHeat = heat; + int tempFuelLeft = fuelRemaining; + if (tempFuelLeft <= maximumFuel/3){ + formattedFuelLeft = EnumChatFormatting.RED+tempFuel+EnumChatFormatting.GRAY; + } + else if (tempFuelLeft >= maximumFuel/3 && tempFuelLeft <= (maximumFuel/3)*2){ + formattedFuelLeft = EnumChatFormatting.YELLOW+tempFuel+EnumChatFormatting.GRAY; + } + else if (tempFuelLeft >= (maximumFuel/3)*2 && tempFuelLeft <= maximumFuel){ + formattedFuelLeft = EnumChatFormatting.GREEN+tempFuel+EnumChatFormatting.GRAY; + } + else { + formattedFuelLeft = EnumChatFormatting.GRAY+tempFuel+EnumChatFormatting.GRAY; + } + if (tempCurrentHeat <= maxHeat/3 && tempCurrentHeat != 0){ + formattedHeat = EnumChatFormatting.GRAY+tempHeat+EnumChatFormatting.GRAY; + } + else if (tempCurrentHeat >= maxHeat/3 && tempMax <= (maxHeat/3)*2 && tempCurrentHeat != 0){ + formattedHeat = EnumChatFormatting.YELLOW+tempHeat+EnumChatFormatting.GRAY; + } + else if (tempCurrentHeat <= (maxHeat/3)*2 && tempMax <= maxHeat && tempCurrentHeat != 0){ + formattedHeat = EnumChatFormatting.RED+tempHeat+EnumChatFormatting.GRAY; + } + else { + formattedHeat = EnumChatFormatting.BLUE+tempHeat+EnumChatFormatting.GRAY; + } + + list.add(EnumChatFormatting.GRAY+"A "+formattedType+" fuel rod."); + list.add(EnumChatFormatting.GRAY+"Running at "+formattedHeat+"K."); + list.add(EnumChatFormatting.GRAY+"Currently there is: "+formattedFuelLeft+"L of fuel left."); + super.addInformation(stack, aPlayer, list, bool); + } + + public String getType(){ + return fuelType; + } + + public int getFuelRemaining(){ + return fuelRemaining; + } + + public int getMaxFuel(){ + return maximumFuel; + } + + public int getFuel(){ + if (thisStack != null){ + int i = thisStack.getItemDamage(); + int r = maximumFuel - i; + return r; + } + return fuelRemaining; + } + + public boolean setFuelRemainingExplicitly(int i){ + int tempFuel = fuelRemaining; + fuelRemaining = i; + if (i != tempFuel){ + return true; + } + return false; + } + + public boolean addFuel(int i){ + int tempFuel = fuelRemaining; + fuelRemaining = tempFuel+i; + if (fuelRemaining != tempFuel){ + return true; + } + return false; + } + + public float getHeat(){ + return heat; + } + + public boolean addHeat(float i){ + float tempFuel = heat; + heat = tempFuel+i; + if (heat != tempFuel){ + return true; + } + return false; + } + +} diff --git a/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Thorium.java b/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Thorium.java new file mode 100644 index 0000000000..0e8230645b --- /dev/null +++ b/src/Java/miscutil/core/item/general/fuelrods/FuelRod_Thorium.java @@ -0,0 +1,13 @@ +package miscutil.core.item.general.fuelrods; + +public class FuelRod_Thorium extends FuelRod_Base{ + + public FuelRod_Thorium(String unlocalizedName, String type, int fuelLeft, int maxFuel) { + super(unlocalizedName, type, fuelLeft, maxFuel); + this.setMaxDamage(maxFuel); + this.maximumFuel = maxFuel; + this.fuelRemaining = fuelLeft; + this.fuelType = type; + } + +} diff --git a/src/Java/miscutil/core/tileentities/ModTileEntities.java b/src/Java/miscutil/core/tileentities/ModTileEntities.java index 4eead783c5..a27e7be6ad 100644 --- a/src/Java/miscutil/core/tileentities/ModTileEntities.java +++ b/src/Java/miscutil/core/tileentities/ModTileEntities.java @@ -1,5 +1,6 @@ package miscutil.core.tileentities; +import miscutil.core.block.heliumgen.tileentity.TileEntityHeliumGenerator; import miscutil.core.util.Utils; import cpw.mods.fml.common.registry.GameRegistry; @@ -10,6 +11,8 @@ public class ModTileEntities { Utils.LOG_INFO("Registering Tile Entities."); //GameRegistry.registerTileEntity(TileEntityReverter.class, "TE_blockGriefSaver"); GameRegistry.registerTileEntity(TileEntityReverter.class, "Tower Reverter"); + GameRegistry.registerTileEntity(TileEntityNHG.class, "NuclearFueledHeliumGenerator"); + GameRegistry.registerTileEntity(TileEntityHeliumGenerator.class, "Helium"); } } diff --git a/src/Java/miscutil/core/tileentities/TileEntityNHG.java b/src/Java/miscutil/core/tileentities/TileEntityNHG.java new file mode 100644 index 0000000000..8813987a7b --- /dev/null +++ b/src/Java/miscutil/core/tileentities/TileEntityNHG.java @@ -0,0 +1,187 @@ +package miscutil.core.tileentities; + +import miscutil.core.item.ModItems; +import miscutil.core.item.general.fuelrods.FuelRod_Base; +import miscutil.core.util.UtilsItems; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.Constants; + +public class TileEntityNHG extends TileEntity implements IInventory +{ + private ItemStack[] items = new ItemStack[19]; //18 + private int internalClock = 0; + + @Override + public int getSizeInventory() + { + return items.length; + } + + @Override + public ItemStack getStackInSlot(int slot) + { + + return items[slot]; + + } + + @Override + public ItemStack decrStackSize(int slot, int amount) + { + if (items[slot] != null) + { + ItemStack itemstack; + + if (items[slot].stackSize == amount) + { + itemstack = items[slot]; + items[slot] = null; + markDirty(); + return itemstack; + } + itemstack = items[slot].splitStack(amount); + if (items[slot].stackSize == 0) items[slot] = null; + markDirty(); + return itemstack; + } + return null; + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) + { + if (items[slot] != null) + { + ItemStack itemstack = items[slot]; + items[slot] = null; + return itemstack; + } + return null; + } + + @Override + public void setInventorySlotContents(int slot, ItemStack stack) + { + if (stack != null){ + items[slot] = stack; + if (stack != null && stack.stackSize > getInventoryStackLimit()) + { + stack.stackSize = getInventoryStackLimit(); + } + + + markDirty(); + } + } + + @Override + public String getInventoryName() + { + return "container.NHG"; + } + + @Override + public boolean hasCustomInventoryName() + { + return false; + } + + @Override + public void readFromNBT(NBTTagCompound nbt) + { + super.readFromNBT(nbt); + NBTTagList list = nbt.getTagList("Items", Constants.NBT.TAG_COMPOUND); + items = new ItemStack[getSizeInventory()]; + + for (int i = 0; i < list.tagCount(); ++i) { NBTTagCompound comp = list.getCompoundTagAt(i); int j = comp.getByte("Slot") & 255; if (j >= 0 && j < items.length) + { + items[j] = ItemStack.loadItemStackFromNBT(comp); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound nbt) + { + super.writeToNBT(nbt); + NBTTagList list = new NBTTagList(); + + for (int i = 0; i < items.length; ++i) + { + if (items[i] != null) + { + NBTTagCompound comp = new NBTTagCompound(); + comp.setByte("Slot", (byte)i); + items[i].writeToNBT(comp); + list.appendTag(comp); + } + } + + nbt.setTag("Items", list); + } + + @Override + public int getInventoryStackLimit() + { + return 64; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer player) + { + return worldObj.getTileEntity(xCoord, yCoord, zCoord) != this ? false : player.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64.0D; + } + + @Override + public void openInventory() {} + + @Override + public void closeInventory() {} + + @Override + public boolean isItemValidForSlot(int slot, ItemStack stack) + { + return true; + } + + //Machine Code - TODO + + @Override + public void updateEntity() { + if (internalClock <= 20){ + internalClock++; + } + else { + ItemStack validFuelRod_Type_A = UtilsItems.getSimpleStack(ModItems.FuelRod_Thorium); + ItemStack validFuelRod_Type_B = UtilsItems.getSimpleStack(ModItems.FuelRod_Uranium); + ItemStack validFuelRod_Type_C = UtilsItems.getSimpleStack(ModItems.FuelRod_Plutonium); + for (int i = 0; i < getSizeInventory(); i++){ + ItemStack tempCurrent = items[i]; + if (tempCurrent == validFuelRod_Type_A ||tempCurrent == validFuelRod_Type_B || tempCurrent == validFuelRod_Type_C){ + Item tempItem = tempCurrent.getItem(); + FuelRod_Base tempItem2 = (FuelRod_Base) tempItem; + if (tempItem2.getHeat() <= 5000){ + tempItem2.addHeat(5); + } + if (tempItem2.getFuelRemaining() >= 1){ + tempItem2.addFuel(-1); + } + ItemStack validFuelRod = UtilsItems.getSimpleStack(tempItem2); + setInventorySlotContents(i, validFuelRod); + } + } + + internalClock=0; + } + super.updateEntity(); + } + + + +}
\ No newline at end of file |