mirror of
https://github.com/HbmMods/Hbm-s-Nuclear-Tech-GIT.git
synced 2026-03-16 06:35:35 +00:00
277 lines
9.0 KiB
Java
277 lines
9.0 KiB
Java
package com.hbm.tileentity.machine;
|
|
|
|
import java.math.BigInteger;
|
|
|
|
import com.hbm.handler.radiation.ChunkRadiationManager;
|
|
import com.hbm.hazard.HazardRegistry;
|
|
import com.hbm.hazard.HazardSystem;
|
|
import com.hbm.interfaces.IControlReceiver;
|
|
import com.hbm.inventory.RecipesCommon.ComparableStack;
|
|
import com.hbm.inventory.container.ContainerMachineAnnihilator;
|
|
import com.hbm.inventory.fluid.FluidType;
|
|
import com.hbm.inventory.fluid.Fluids;
|
|
import com.hbm.inventory.fluid.tank.FluidTank;
|
|
import com.hbm.inventory.fluid.trait.FT_Polluting;
|
|
import com.hbm.inventory.fluid.trait.FluidTrait.FluidReleaseType;
|
|
import com.hbm.inventory.gui.GUIMachineAnnihilator;
|
|
import com.hbm.items.machine.IItemFluidIdentifier;
|
|
import com.hbm.saveddata.AnnihilatorSavedData;
|
|
import com.hbm.saveddata.AnnihilatorSavedData.AnnihilatorPool;
|
|
import com.hbm.tileentity.IGUIProvider;
|
|
import com.hbm.tileentity.TileEntityMachineBase;
|
|
import com.hbm.util.ParticleUtil;
|
|
import com.hbm.util.fauxpointtwelve.DirPos;
|
|
|
|
import api.hbm.energymk2.IEnergyReceiverMK2.ConnectionPriority;
|
|
import api.hbm.fluidmk2.IFluidStandardReceiverMK2;
|
|
import cpw.mods.fml.common.network.ByteBufUtils;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
public class TileEntityMachineAnnihilator extends TileEntityMachineBase implements IFluidStandardReceiverMK2, IControlReceiver, IGUIProvider {
|
|
|
|
public String pool = "Recycling";
|
|
public int timer;
|
|
|
|
public FluidTank tank;
|
|
public BigInteger monitorBigInt = BigInteger.ZERO;
|
|
|
|
public TileEntityMachineAnnihilator() {
|
|
super(11);
|
|
|
|
this.tank = new FluidTank(Fluids.NONE, 2_500_000);
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return "container.annihilator";
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
|
|
if(!worldObj.isRemote) {
|
|
|
|
this.tank.setType(1, slots);
|
|
|
|
if(this.pool != null && !this.pool.isEmpty()) {
|
|
|
|
for(DirPos pos : getConPos()) {
|
|
if(tank.getTankType() != Fluids.NONE) this.trySubscribe(tank.getTankType(), worldObj, pos);
|
|
}
|
|
|
|
AnnihilatorSavedData data = AnnihilatorSavedData.getData(worldObj);
|
|
boolean didSomething = false;
|
|
|
|
if(slots[0] != null) {
|
|
onDestroy(slots[0]);
|
|
tryAddPayout(data.pushToPool(pool, slots[0], false));
|
|
this.slots[0] = null;
|
|
this.markChanged();
|
|
didSomething = true;
|
|
}
|
|
if(tank.getFill() > 0) {
|
|
FT_Polluting.pollute(worldObj, xCoord, yCoord, zCoord, tank.getTankType(), FluidReleaseType.BURN, tank.getFill() * 2);
|
|
tryAddPayout(data.pushToPool(pool, tank.getTankType(), tank.getFill(), false));
|
|
tank.setFill(0);
|
|
this.markChanged();
|
|
didSomething = true;
|
|
}
|
|
|
|
if(didSomething) {
|
|
ForgeDirection dir = ForgeDirection.getOrientation(this.getBlockMetadata() - 10);
|
|
ParticleUtil.spawnGasFlame(worldObj, this.xCoord + 0.5 - dir.offsetX * 3, this.yCoord + 8.75, this.zCoord + 0.5 - dir.offsetZ * 3, worldObj.rand.nextGaussian() * 0.05, 0.1, worldObj.rand.nextGaussian() * 0.05);
|
|
|
|
if(worldObj.getTotalWorldTime() % 3 == 0)
|
|
this.worldObj.playSoundEffect(this.xCoord + 0.5 - dir.offsetX * 3, this.yCoord + 8.75, this.zCoord + 0.5 - dir.offsetZ * 3, "hbm:weapon.flamethrowerShoot", getVolume(1F), 0.5F + worldObj.rand.nextFloat() * 0.25F);
|
|
}
|
|
|
|
if(slots[8] != null) {
|
|
if(slots[8].getItem() instanceof IItemFluidIdentifier) {
|
|
IItemFluidIdentifier id = (IItemFluidIdentifier) slots[8].getItem();
|
|
FluidType type = id.getType(worldObj, xCoord, yCoord, zCoord, slots[8]);
|
|
monitor(data, type);
|
|
} else {
|
|
monitor(data, new ComparableStack(slots[8]).makeSingular());
|
|
}
|
|
}
|
|
|
|
if(slots[9] != null) {
|
|
ItemStack single = slots[9].copy();
|
|
single.stackSize = 1;
|
|
onDestroy(single);
|
|
ItemStack payout = data.pushToPool(pool, single, true);
|
|
this.decrStackSize(9, 1);
|
|
if(payout != null) {
|
|
if(slots[10] == null) {
|
|
slots[10] = payout;
|
|
} else if(slots[10] != null && slots[10].getItem() == payout.getItem() && slots[10].getItemDamage() == payout.getItemDamage() &&
|
|
ItemStack.areItemStackTagsEqual(slots[10], payout) && slots[10].getMaxStackSize() >= slots[10].stackSize + payout.stackSize) {
|
|
slots[10].stackSize += payout.stackSize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.networkPackNT(25);
|
|
}
|
|
}
|
|
|
|
public void onDestroy(ItemStack stack) {
|
|
float radiation = HazardSystem.getHazardLevelFromStack(stack, HazardRegistry.RADIATION);
|
|
if(radiation > 0) {
|
|
ForgeDirection dir = ForgeDirection.getOrientation(this.getBlockMetadata() - 10);
|
|
ChunkRadiationManager.proxy.incrementRad(worldObj, this.xCoord - dir.offsetX * 3, this.yCoord + 9, this.zCoord - dir.offsetZ * 3, Math.min(radiation * 5F, 1_000F));
|
|
}
|
|
}
|
|
|
|
public DirPos[] getConPos() {
|
|
ForgeDirection dir = ForgeDirection.getOrientation(this.getBlockMetadata() - 10);
|
|
ForgeDirection rot = dir.getRotation(ForgeDirection.UP);
|
|
|
|
return new DirPos[] {
|
|
new DirPos(xCoord + dir.offsetX * 5, yCoord, zCoord + dir.offsetZ * 5, dir),
|
|
new DirPos(xCoord + dir.offsetX * 3 + rot.offsetX * 2, yCoord, zCoord + dir.offsetZ * 3 + rot.offsetZ * 2, rot),
|
|
new DirPos(xCoord + dir.offsetX * 3 - rot.offsetX * 2, yCoord, zCoord + dir.offsetZ * 3 - rot.offsetZ * 2, rot.getOpposite())
|
|
};
|
|
}
|
|
|
|
public void monitor(AnnihilatorSavedData data, Object type) {
|
|
AnnihilatorPool pool = data.pools.get(this.pool);
|
|
if(pool != null) {
|
|
this.monitorBigInt = pool.items.get(type);
|
|
if(this.monitorBigInt == null) this.monitorBigInt = BigInteger.ZERO;
|
|
} else {
|
|
this.monitorBigInt = BigInteger.ZERO;
|
|
}
|
|
}
|
|
|
|
public void tryAddPayout(ItemStack payout) {
|
|
if(payout == null) return;
|
|
|
|
for(int i = 2; i <= 7; i++) {
|
|
if(slots[i] != null && slots[i].getItem() == payout.getItem() && slots[i].getItemDamage() == payout.getItemDamage() &&
|
|
ItemStack.areItemStackTagsEqual(slots[i], payout) && slots[i].getMaxStackSize() >= slots[i].stackSize + payout.stackSize) {
|
|
slots[i].stackSize += payout.stackSize;
|
|
this.markDirty();
|
|
return;
|
|
}
|
|
}
|
|
|
|
for(int i = 2; i <= 7; i++) {
|
|
if(slots[i] == null) {
|
|
slots[i] = payout;
|
|
this.markDirty();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int slot, ItemStack stack) {
|
|
if(slot == 0) return true; // trash
|
|
if(slot == 1 && stack.getItem() instanceof IItemFluidIdentifier) return true;
|
|
if(slot == 8) return true; // monitor
|
|
if(slot == 9) return true; // payout request
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
|
|
return slot >= 2 && slot <= 7;
|
|
}
|
|
|
|
@Override
|
|
public int[] getAccessibleSlotsFromSide(int side) {
|
|
return new int[] {0, 2, 3, 4, 5, 6, 7};
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbt) {
|
|
super.readFromNBT(nbt);
|
|
this.tank.readFromNBT(nbt, "t");
|
|
this.pool = nbt.getString("pool");
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbt) {
|
|
super.writeToNBT(nbt);
|
|
this.tank.writeToNBT(nbt, "t");
|
|
nbt.setString("pool", pool);
|
|
}
|
|
|
|
@Override
|
|
public void serialize(ByteBuf buf) {
|
|
super.serialize(buf);
|
|
ByteBufUtils.writeUTF8String(buf, this.pool == null ? "" : this.pool);
|
|
byte[] array = this.monitorBigInt.toByteArray();
|
|
buf.writeInt(array.length);
|
|
for(byte b : array) buf.writeByte(b);
|
|
}
|
|
|
|
@Override
|
|
public void deserialize(ByteBuf buf) {
|
|
super.deserialize(buf);
|
|
this.pool = ByteBufUtils.readUTF8String(buf);
|
|
byte[] array = new byte[buf.readInt()];
|
|
for(int i = 0 ; i < array.length; i++) array[i] = buf.readByte();
|
|
this.monitorBigInt = new BigInteger(array);
|
|
}
|
|
|
|
@Override public FluidTank[] getAllTanks() { return new FluidTank[] {tank}; }
|
|
@Override public FluidTank[] getReceivingTanks() { return new FluidTank[] {tank}; }
|
|
@Override public ConnectionPriority getFluidPriority() { return ConnectionPriority.LOW; }
|
|
|
|
@Override public Container provideContainer(int ID, EntityPlayer player, World world, int x, int y, int z) { return new ContainerMachineAnnihilator(player.inventory, this); }
|
|
@Override @SideOnly(Side.CLIENT) public Object provideGUI(int ID, EntityPlayer player, World world, int x, int y, int z) { return new GUIMachineAnnihilator(player.inventory, this); }
|
|
|
|
@Override
|
|
public boolean hasPermission(EntityPlayer player) {
|
|
return this.isUseableByPlayer(player);
|
|
}
|
|
|
|
@Override
|
|
public void receiveControl(NBTTagCompound data) {
|
|
if(data.hasKey("pool")) {
|
|
String pool = data.getString("pool");
|
|
if(pool != null && !pool.isEmpty()) {
|
|
this.pool = pool;
|
|
this.markChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
AxisAlignedBB bb = null;
|
|
|
|
@Override
|
|
public AxisAlignedBB getRenderBoundingBox() {
|
|
|
|
if(bb == null) {
|
|
bb = AxisAlignedBB.getBoundingBox(
|
|
xCoord - 5,
|
|
yCoord,
|
|
zCoord - 5,
|
|
xCoord + 6,
|
|
yCoord + 8,
|
|
zCoord + 6
|
|
);
|
|
}
|
|
|
|
return bb;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public double getMaxRenderDistanceSquared() {
|
|
return 65536.0D;
|
|
}
|
|
}
|