Files
Mekanism-Community-Edition/src/main/java/mekanism/common/tile/TileEntityChargepad.java
T
Ben Spiers 725b7463f0 Make the mod classes significantly less godlike.
Move Config variables into their own class, (in api because other stuff in API references config, may make sense to move it back to common later), and move Blocks and Items into final variables in their own classes. It looks a lot cleaner this way and my OCD can finally rest now.
2014-08-01 01:35:06 +01:00

242 lines
5.6 KiB
Java

package mekanism.common.tile;
import ic2.api.item.ElectricItem;
import ic2.api.item.IElectricItem;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Random;
import mekanism.api.Coord4D;
import mekanism.api.MekanismConfig.general;
import mekanism.api.energy.EnergizedItemManager;
import mekanism.api.energy.IEnergizedItem;
import mekanism.client.sound.IHasSound;
import mekanism.common.IActiveState;
import mekanism.common.Mekanism;
import mekanism.common.block.BlockMachine.MachineType;
import mekanism.common.entity.EntityRobit;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.util.MekanismUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.AxisAlignedBB;
import net.minecraftforge.common.util.ForgeDirection;
import cofh.api.energy.IEnergyContainerItem;
public class TileEntityChargepad extends TileEntityElectricBlock implements IActiveState, IHasSound
{
public boolean isActive;
public boolean prevActive;
public Random random = new Random();
public TileEntityChargepad()
{
super("Chargepad", MachineType.CHARGEPAD.baseEnergy);
inventory = new ItemStack[0];
}
@Override
public void onUpdate()
{
super.onUpdate();
if(!worldObj.isRemote)
{
isActive = false;
List<EntityLivingBase> entities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, AxisAlignedBB.getBoundingBox(xCoord, yCoord, zCoord, xCoord+1, yCoord+0.2, zCoord+1));
for(EntityLivingBase entity : entities)
{
if(entity instanceof EntityPlayer || entity instanceof EntityRobit)
{
isActive = true;
}
if(getEnergy() > 0)
{
if(entity instanceof EntityRobit)
{
EntityRobit robit = (EntityRobit)entity;
double canGive = Math.min(getEnergy(), 1000);
double toGive = Math.min(robit.MAX_ELECTRICITY-robit.getEnergy(), canGive);
robit.setEnergy(robit.getEnergy() + toGive);
setEnergy(getEnergy() - toGive);
}
else if(entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer)entity;
double prevEnergy = getEnergy();
for(ItemStack itemstack : player.inventory.armorInventory)
{
chargeItemStack(itemstack);
if(prevEnergy != getEnergy())
{
break;
}
}
for(ItemStack itemstack : player.inventory.mainInventory)
{
chargeItemStack(itemstack);
if(prevEnergy != getEnergy())
{
break;
}
}
}
}
}
if(prevActive != isActive)
{
worldObj.playSoundEffect(xCoord + 0.5, yCoord + 0.1, zCoord + 0.5, "random.click", 0.3F, isActive ? 0.6F : 0.5F);
setActive(isActive);
}
}
else {
Mekanism.proxy.registerSound(this);
if(isActive)
{
worldObj.spawnParticle("reddust", xCoord+random.nextDouble(), yCoord+0.15, zCoord+random.nextDouble(), 0, 0, 0);
}
}
}
public void chargeItemStack(ItemStack itemstack)
{
if(itemstack != null)
{
if(itemstack.getItem() instanceof IEnergizedItem)
{
setEnergy(getEnergy() - EnergizedItemManager.charge(itemstack, getEnergy()));
}
else if(MekanismUtils.useIC2() && itemstack.getItem() instanceof IElectricItem)
{
double sent = ElectricItem.manager.charge(itemstack, (int)(getEnergy()* general.TO_IC2), 4, true, false)* general.FROM_IC2;
setEnergy(getEnergy() - sent);
}
else if(MekanismUtils.useRF() && itemstack.getItem() instanceof IEnergyContainerItem)
{
IEnergyContainerItem item = (IEnergyContainerItem)itemstack.getItem();
int itemEnergy = (int)Math.round(Math.min(Math.sqrt(item.getMaxEnergyStored(itemstack)), item.getMaxEnergyStored(itemstack) - item.getEnergyStored(itemstack)));
int toTransfer = (int)Math.round(Math.min(itemEnergy, (getEnergy()* general.TO_TE)));
setEnergy(getEnergy() - (item.receiveEnergy(itemstack, toTransfer, false)* general.FROM_TE));
}
}
}
@Override
public void invalidate()
{
super.invalidate();
if(worldObj.isRemote)
{
Mekanism.proxy.unregisterSound(this);
}
}
@Override
protected EnumSet<ForgeDirection> getConsumingSides()
{
return EnumSet.of(ForgeDirection.DOWN, ForgeDirection.getOrientation(facing).getOpposite());
}
@Override
public boolean getActive()
{
return isActive;
}
@Override
public void setActive(boolean active)
{
isActive = active;
if(prevActive != active)
{
Mekanism.packetHandler.sendToAll(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())));
}
prevActive = active;
}
@Override
public void readFromNBT(NBTTagCompound nbtTags)
{
super.readFromNBT(nbtTags);
isActive = nbtTags.getBoolean("isActive");
}
@Override
public void writeToNBT(NBTTagCompound nbtTags)
{
super.writeToNBT(nbtTags);
nbtTags.setBoolean("isActive", isActive);
}
@Override
public void handlePacketData(ByteBuf dataStream)
{
super.handlePacketData(dataStream);
isActive = dataStream.readBoolean();
MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord);
}
@Override
public ArrayList getNetworkedData(ArrayList data)
{
super.getNetworkedData(data);
data.add(isActive);
return data;
}
@Override
public boolean canSetFacing(int side)
{
return side != 0 && side != 1;
}
@Override
public String getSoundPath()
{
return "Chargepad.ogg";
}
@Override
public float getVolumeMultiplier()
{
return 0.4F;
}
@Override
public boolean renderUpdate()
{
return false;
}
@Override
public boolean lightUpdate()
{
return true;
}
}