mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 04:52:25 +00:00
388 lines
10 KiB
Java
388 lines
10 KiB
Java
package mekanism.common.item;
|
|
|
|
import ic2.api.item.IElectricItemManager;
|
|
import ic2.api.item.ISpecialElectricItem;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.EnumColor;
|
|
import mekanism.api.MekanismConfig.general;
|
|
import mekanism.api.Range4D;
|
|
import mekanism.api.energy.IEnergizedItem;
|
|
import mekanism.api.transmitters.TransmissionType;
|
|
import mekanism.client.MekKeyHandler;
|
|
import mekanism.client.MekanismKeyHandler;
|
|
import mekanism.common.Mekanism;
|
|
import mekanism.common.Tier.BaseTier;
|
|
import mekanism.common.Tier.EnergyCubeTier;
|
|
import mekanism.common.base.ISideConfiguration;
|
|
import mekanism.common.base.ISustainedInventory;
|
|
import mekanism.common.base.ITierItem;
|
|
import mekanism.common.capabilities.ItemCapabilityWrapper;
|
|
import mekanism.common.integration.IC2ItemManager;
|
|
import mekanism.common.integration.TeslaItemWrapper;
|
|
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
|
|
import mekanism.common.security.ISecurityItem;
|
|
import mekanism.common.security.ISecurityTile;
|
|
import mekanism.common.security.ISecurityTile.SecurityMode;
|
|
import mekanism.common.tile.TileEntityEnergyCube;
|
|
import mekanism.common.util.ItemDataUtils;
|
|
import mekanism.common.util.LangUtils;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import mekanism.common.util.SecurityUtils;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.settings.GameSettings;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemBlock;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraft.util.math.MathHelper;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.capabilities.ICapabilityProvider;
|
|
import net.minecraftforge.fml.common.Optional.Interface;
|
|
import net.minecraftforge.fml.common.Optional.InterfaceList;
|
|
import net.minecraftforge.fml.common.Optional.Method;
|
|
import net.minecraftforge.fml.relauncher.Side;
|
|
import net.minecraftforge.fml.relauncher.SideOnly;
|
|
import cofh.api.energy.IEnergyContainerItem;
|
|
|
|
@InterfaceList({
|
|
@Interface(iface = "ic2.api.item.ISpecialElectricItem", modid = "IC2")
|
|
})
|
|
public class ItemBlockEnergyCube extends ItemBlock implements IEnergizedItem, ISpecialElectricItem, ISustainedInventory, IEnergyContainerItem, ISecurityItem, ITierItem
|
|
{
|
|
public Block metaBlock;
|
|
|
|
public ItemBlockEnergyCube(Block block)
|
|
{
|
|
super(block);
|
|
metaBlock = block;
|
|
setMaxStackSize(1);
|
|
setHasSubtypes(true);
|
|
setNoRepair();
|
|
setCreativeTab(Mekanism.tabMekanism);
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public void addInformation(ItemStack itemstack, EntityPlayer entityplayer, List<String> list, boolean flag)
|
|
{
|
|
list.add(EnumColor.BRIGHT_GREEN + LangUtils.localize("tooltip.storedEnergy") + ": " + EnumColor.GREY + MekanismUtils.getEnergyDisplay(getEnergy(itemstack)));
|
|
list.add(EnumColor.INDIGO + LangUtils.localize("tooltip.capacity") + ": " + EnumColor.GREY + MekanismUtils.getEnergyDisplay(EnergyCubeTier.values()[getBaseTier(itemstack).ordinal()].maxEnergy));
|
|
|
|
if(!MekKeyHandler.getIsKeyPressed(MekanismKeyHandler.sneakKey))
|
|
{
|
|
list.add(LangUtils.localize("tooltip.hold") + " " + EnumColor.AQUA + GameSettings.getKeyDisplayString(MekanismKeyHandler.sneakKey.getKeyCode()) + EnumColor.GREY + " " + LangUtils.localize("tooltip.forDetails") + ".");
|
|
}
|
|
else {
|
|
if(hasSecurity(itemstack))
|
|
{
|
|
list.add(SecurityUtils.getOwnerDisplay(entityplayer.getName(), getOwner(itemstack)));
|
|
list.add(EnumColor.GREY + LangUtils.localize("gui.security") + ": " + SecurityUtils.getSecurityDisplay(itemstack, Side.CLIENT));
|
|
|
|
if(SecurityUtils.isOverridden(itemstack, Side.CLIENT))
|
|
{
|
|
list.add(EnumColor.RED + "(" + LangUtils.localize("gui.overridden") + ")");
|
|
}
|
|
}
|
|
|
|
list.add(EnumColor.AQUA + LangUtils.localize("tooltip.inventory") + ": " + EnumColor.GREY + LangUtils.transYesNo(getInventory(itemstack) != null && getInventory(itemstack).tagCount() != 0));
|
|
}
|
|
}
|
|
|
|
public ItemStack getUnchargedItem(EnergyCubeTier tier)
|
|
{
|
|
ItemStack stack = new ItemStack(this);
|
|
setBaseTier(stack, tier.getBaseTier());
|
|
|
|
return stack;
|
|
}
|
|
|
|
@Override
|
|
public String getItemStackDisplayName(ItemStack itemstack)
|
|
{
|
|
return LangUtils.localize("tile.EnergyCube" + getBaseTier(itemstack).getSimpleName() + ".name");
|
|
}
|
|
|
|
@Override
|
|
public boolean placeBlockAt(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, IBlockState state)
|
|
{
|
|
boolean place = super.placeBlockAt(stack, player, world, pos, side, hitX, hitY, hitZ, state);
|
|
|
|
if(place)
|
|
{
|
|
TileEntityEnergyCube tileEntity = (TileEntityEnergyCube)world.getTileEntity(pos);
|
|
tileEntity.tier = EnergyCubeTier.values()[getBaseTier(stack).ordinal()];
|
|
tileEntity.electricityStored = getEnergy(stack);
|
|
|
|
if(tileEntity.tier == EnergyCubeTier.CREATIVE)
|
|
{
|
|
tileEntity.configComponent.fillConfig(TransmissionType.ENERGY, tileEntity.getEnergy() > 0 ? 2 : 1);
|
|
}
|
|
|
|
if(tileEntity instanceof ISecurityTile)
|
|
{
|
|
ISecurityTile security = (ISecurityTile)tileEntity;
|
|
security.getSecurity().setOwner(getOwner(stack));
|
|
|
|
if(hasSecurity(stack))
|
|
{
|
|
security.getSecurity().setMode(getSecurity(stack));
|
|
}
|
|
|
|
if(getOwner(stack) == null)
|
|
{
|
|
security.getSecurity().setOwner(player.getName());
|
|
}
|
|
}
|
|
|
|
if(tileEntity instanceof ISideConfiguration)
|
|
{
|
|
ISideConfiguration config = (ISideConfiguration)tileEntity;
|
|
|
|
if(ItemDataUtils.hasData(stack, "sideDataStored"))
|
|
{
|
|
config.getConfig().read(ItemDataUtils.getDataMap(stack));
|
|
config.getEjector().read(ItemDataUtils.getDataMap(stack));
|
|
}
|
|
}
|
|
|
|
((ISustainedInventory)tileEntity).setInventory(getInventory(stack));
|
|
|
|
if(!world.isRemote)
|
|
{
|
|
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(tileEntity), tileEntity.getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(tileEntity)));
|
|
}
|
|
}
|
|
|
|
return place;
|
|
}
|
|
|
|
@Override
|
|
public BaseTier getBaseTier(ItemStack itemstack)
|
|
{
|
|
if(!itemstack.hasTagCompound())
|
|
{
|
|
return BaseTier.BASIC;
|
|
}
|
|
|
|
return BaseTier.values()[itemstack.getTagCompound().getInteger("tier")];
|
|
}
|
|
|
|
@Override
|
|
public void setBaseTier(ItemStack itemstack, BaseTier tier)
|
|
{
|
|
if(!itemstack.hasTagCompound())
|
|
{
|
|
itemstack.setTagCompound(new NBTTagCompound());
|
|
}
|
|
|
|
itemstack.getTagCompound().setInteger("tier", tier.ordinal());
|
|
}
|
|
|
|
@Override
|
|
public void setInventory(NBTTagList nbtTags, Object... data)
|
|
{
|
|
if(data[0] instanceof ItemStack)
|
|
{
|
|
ItemDataUtils.setList((ItemStack)data[0], "Items", nbtTags);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public NBTTagList getInventory(Object... data)
|
|
{
|
|
if(data[0] instanceof ItemStack)
|
|
{
|
|
return ItemDataUtils.getList((ItemStack)data[0], "Items");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public double getEnergy(ItemStack itemStack)
|
|
{
|
|
if(!itemStack.hasTagCompound())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return ItemDataUtils.getDouble(itemStack, "energyStored");
|
|
}
|
|
|
|
@Override
|
|
public void setEnergy(ItemStack itemStack, double amount)
|
|
{
|
|
if(getBaseTier(itemStack) == BaseTier.CREATIVE && amount != Double.MAX_VALUE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ItemDataUtils.setDouble(itemStack, "energyStored", Math.max(Math.min(amount, getMaxEnergy(itemStack)), 0));
|
|
}
|
|
|
|
@Override
|
|
public double getMaxEnergy(ItemStack itemStack)
|
|
{
|
|
return EnergyCubeTier.values()[getBaseTier(itemStack).ordinal()].maxEnergy;
|
|
}
|
|
|
|
@Override
|
|
public double getMaxTransfer(ItemStack itemStack)
|
|
{
|
|
return getMaxEnergy(itemStack)*0.005;
|
|
}
|
|
|
|
@Override
|
|
public boolean canReceive(ItemStack itemStack)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean canSend(ItemStack itemStack)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int receiveEnergy(ItemStack theItem, int energy, boolean simulate)
|
|
{
|
|
if(canReceive(theItem))
|
|
{
|
|
double energyNeeded = getMaxEnergy(theItem)-getEnergy(theItem);
|
|
double toReceive = Math.min(energy*general.FROM_RF, energyNeeded);
|
|
|
|
if(!simulate)
|
|
{
|
|
setEnergy(theItem, getEnergy(theItem) + toReceive);
|
|
}
|
|
|
|
return (int)Math.round(toReceive*general.TO_RF);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int extractEnergy(ItemStack theItem, int energy, boolean simulate)
|
|
{
|
|
if(canSend(theItem))
|
|
{
|
|
double energyRemaining = getEnergy(theItem);
|
|
double toSend = Math.min((energy*general.FROM_RF), energyRemaining);
|
|
|
|
if(!simulate)
|
|
{
|
|
setEnergy(theItem, getEnergy(theItem) - toSend);
|
|
}
|
|
|
|
return (int)Math.round(toSend*general.TO_RF);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int getEnergyStored(ItemStack theItem)
|
|
{
|
|
return (int)(getEnergy(theItem)*general.TO_RF);
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyStored(ItemStack theItem)
|
|
{
|
|
return (int)(getMaxEnergy(theItem)*general.TO_RF);
|
|
}
|
|
|
|
@Override
|
|
public boolean showDurabilityBar(ItemStack stack)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public double getDurabilityForDisplay(ItemStack stack)
|
|
{
|
|
return 1D-(getEnergy(stack)/getMaxEnergy(stack));
|
|
}
|
|
|
|
@Override
|
|
public int getRGBDurabilityForDisplay(ItemStack stack)
|
|
{
|
|
return MathHelper.hsvToRGB(Math.max(0.0F, (float)(1-getDurabilityForDisplay(stack))) / 3.0F, 1.0F, 1.0F);
|
|
}
|
|
|
|
@Override
|
|
@Method(modid = "IC2")
|
|
public IElectricItemManager getManager(ItemStack itemStack)
|
|
{
|
|
return IC2ItemManager.getManager(this);
|
|
}
|
|
|
|
@Override
|
|
public String getOwner(ItemStack stack)
|
|
{
|
|
if(ItemDataUtils.hasData(stack, "owner"))
|
|
{
|
|
return ItemDataUtils.getString(stack, "owner");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void setOwner(ItemStack stack, String owner)
|
|
{
|
|
if(owner == null || owner.isEmpty())
|
|
{
|
|
ItemDataUtils.removeData(stack, "owner");
|
|
return;
|
|
}
|
|
|
|
ItemDataUtils.setString(stack, "owner", owner);
|
|
}
|
|
|
|
@Override
|
|
public SecurityMode getSecurity(ItemStack stack)
|
|
{
|
|
if(!general.allowProtection)
|
|
{
|
|
return SecurityMode.PUBLIC;
|
|
}
|
|
|
|
return SecurityMode.values()[ItemDataUtils.getInt(stack, "security")];
|
|
}
|
|
|
|
@Override
|
|
public void setSecurity(ItemStack stack, SecurityMode mode)
|
|
{
|
|
ItemDataUtils.setInt(stack, "security", mode.ordinal());
|
|
}
|
|
|
|
@Override
|
|
public boolean hasSecurity(ItemStack stack)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasOwner(ItemStack stack)
|
|
{
|
|
return hasSecurity(stack);
|
|
}
|
|
|
|
@Override
|
|
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
|
|
{
|
|
return new ItemCapabilityWrapper(stack, new TeslaItemWrapper());
|
|
}
|
|
}
|