generated from tilera/1710mod
431 lines
16 KiB
Java
431 lines
16 KiB
Java
package atomicscience.fenlie;
|
|
|
|
import atomicscience.AtomicScience;
|
|
import atomicscience.MegaTNTExplusion;
|
|
import atomicscience.api.IFissileMaterial;
|
|
import atomicscience.api.IReactor;
|
|
import atomicscience.api.ITemperature;
|
|
import atomicscience.api.poison.PoisonRadiation;
|
|
import atomicscience.wujian.ItBreederFuel;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import java.util.List;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.network.NetworkManager;
|
|
import net.minecraft.network.Packet;
|
|
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTank;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
import universalelectricity.core.vector.Vector3;
|
|
import universalelectricity.prefab.tile.TileEntityDisableable;
|
|
|
|
public class TFissionReactor extends TileEntityDisableable
|
|
implements IInventory, ITemperature, IReactor, IFluidHandler {
|
|
|
|
public static final int BAN_JING = 2;
|
|
public static final int WEN_DU = 2000;
|
|
public float wenDu = 0.0F;
|
|
private ItemStack[] containingItems = new ItemStack[1];
|
|
public float rotation = 0.0F;
|
|
private TFissionReactor cachedZhuYao = null;
|
|
public FluidTank wasteTank;
|
|
|
|
public TFissionReactor() {
|
|
this.wasteTank = new FluidTank(AtomicScience.FLUID_TOXIC_WASTE, 0, 800000);
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
super.updateEntity();
|
|
if (this.cachedZhuYao == null || super.ticks % 20L == 0L) {
|
|
this.zhaoZuiDi();
|
|
}
|
|
|
|
if (!this.isDisabled()) {
|
|
if (this.cachedZhuYao != this && this.getStackInSlot(0) != null &&
|
|
this.cachedZhuYao.getStackInSlot(0) == null) {
|
|
this.cachedZhuYao.setInventorySlotContents(0, this.getStackInSlot(0));
|
|
this.setInventorySlotContents(0, (ItemStack) null);
|
|
}
|
|
|
|
ItemStack fissileFuel = this.cachedZhuYao.getStackInSlot(0);
|
|
int i;
|
|
if (fissileFuel != null && fissileFuel.getItem() instanceof IFissileMaterial) {
|
|
i = ((IFissileMaterial) fissileFuel.getItem()).onFissile(this);
|
|
if (!this.worldObj.isRemote) {
|
|
if (i == 0) {
|
|
fissileFuel.setItemDamage(Math.min(fissileFuel.getItemDamage() + 1,
|
|
fissileFuel.getMaxDamage()));
|
|
if (fissileFuel.getItemDamage() >= fissileFuel.getMaxDamage()) {
|
|
this.cachedZhuYao.setInventorySlotContents(0, (ItemStack) null);
|
|
}
|
|
} else if (i == 2) {
|
|
fissileFuel.setItemDamage(
|
|
Math.max(fissileFuel.getItemDamage() - 1, 0));
|
|
}
|
|
}
|
|
|
|
if (super.ticks % 20L == 0L &&
|
|
(double) this.worldObj.rand.nextFloat() > 0.65D) {
|
|
List<EntityLivingBase> entitiesInRange = this.worldObj.getEntitiesWithinAABB(
|
|
EntityLivingBase.class,
|
|
AxisAlignedBB.getBoundingBox(
|
|
(double) (this.xCoord - 4), (double) (this.yCoord - 4),
|
|
(double) (this.xCoord - 4), (double) (this.xCoord + 4),
|
|
(double) (this.yCoord + 4), (double) (this.xCoord + 4)));
|
|
|
|
for (EntityLivingBase entity : entitiesInRange) {
|
|
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(this), entity);
|
|
}
|
|
}
|
|
|
|
if ((double) this.worldObj.rand.nextFloat() > 0.5D) {
|
|
this.wasteTank.fill(
|
|
new FluidStack(AtomicScience.FLUID_TOXIC_WASTE, 1), true);
|
|
}
|
|
}
|
|
|
|
if (this.wenDu > 2000.0F) {
|
|
this.meltDown();
|
|
} else if (this.wenDu > 100.0F &&
|
|
(fissileFuel == null ||
|
|
!(fissileFuel.getItem() instanceof ItBreederFuel))) {
|
|
for (int x = -2; x <= 2; ++x) {
|
|
for (int z = -2; z <= 2; ++z) {
|
|
Vector3 offsetPos = new Vector3(this);
|
|
offsetPos.add(new Vector3((double) x, 0.0D, (double) z));
|
|
Block offsetBlock = this.worldObj.getBlock(
|
|
offsetPos.intX(), offsetPos.intY(), offsetPos.intZ());
|
|
if (offsetBlock != Blocks.water) {
|
|
if (this.isOverToxic() && !this.worldObj.isRemote &&
|
|
(double) this.worldObj.rand.nextFloat() > 0.999D) {
|
|
if (offsetBlock == Blocks.grass) {
|
|
offsetPos.setBlock(this.worldObj,
|
|
AtomicScience.blockRadioactive);
|
|
} else if (offsetBlock != Blocks.air) {
|
|
offsetPos.setBlock(
|
|
this.worldObj,
|
|
this.wasteTank.getFluid().getFluid().getBlock());
|
|
}
|
|
|
|
this.wasteTank.drain(1000, true);
|
|
}
|
|
} else if (super.ticks %
|
|
(long) ((int) Math.max(
|
|
40.0F - this.wenDu / 2000.0F * 40.0F, 2.0F)) == 0L) {
|
|
AtomicScience.boilWater(this.worldObj, offsetPos, 3, 8);
|
|
this.wenDu = (float) ((double) this.wenDu - 0.2D);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int direction = 2; direction < 6; ++direction) {
|
|
Vector3 neighborPos = new Vector3(this);
|
|
neighborPos.modifyPositionFromSide(
|
|
ForgeDirection.getOrientation(direction));
|
|
if (neighborPos.getBlock(this.worldObj) == AtomicScience.bControlRod) {
|
|
this.setTemperature(this.getTemperature() - 0.5F);
|
|
}
|
|
}
|
|
|
|
if (!this.worldObj.isRemote) {
|
|
this.setTemperature(this.getTemperature() - 1.1F);
|
|
}
|
|
}
|
|
|
|
if (!this.worldObj.isRemote && super.ticks % 60L == 0L) {
|
|
this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
|
|
}
|
|
}
|
|
|
|
public boolean isOverToxic() {
|
|
return AtomicScience.ALLOW_TOXIC_WASTE &&
|
|
// TODO >=?
|
|
this.wasteTank.getFluidAmount() > this.wasteTank.getCapacity();
|
|
}
|
|
|
|
public void updatePositionStatus() {
|
|
boolean top = (new Vector3(this))
|
|
.add(new Vector3(0.0D, 1.0D, 0.0D))
|
|
.getTileEntity(this.worldObj) instanceof TFissionReactor;
|
|
boolean bottom = (new Vector3(this))
|
|
.add(new Vector3(0.0D, -1.0D, 0.0D))
|
|
.getTileEntity(this.worldObj) instanceof TFissionReactor;
|
|
if (top && bottom) {
|
|
this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord,
|
|
this.zCoord, 1, 3);
|
|
} else if (top) {
|
|
this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord,
|
|
this.zCoord, 0, 3);
|
|
} else {
|
|
this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord,
|
|
this.zCoord, 2, 3);
|
|
}
|
|
}
|
|
|
|
public TFissionReactor zhaoZuiDi() {
|
|
Vector3 checkPosition = new Vector3(this);
|
|
TFissionReactor tile = null;
|
|
|
|
do {
|
|
TileEntity newTile = checkPosition.getTileEntity(this.worldObj);
|
|
if (!(newTile instanceof TFissionReactor)) {
|
|
this.cachedZhuYao = tile;
|
|
return tile;
|
|
}
|
|
|
|
tile = (TFissionReactor) newTile;
|
|
--checkPosition.y;
|
|
} while (tile != null);
|
|
|
|
this.cachedZhuYao = this;
|
|
return this;
|
|
}
|
|
|
|
public int getHeight() {
|
|
int height = 0;
|
|
Vector3 checkPosition = new Vector3(this);
|
|
|
|
for (Object tile = this; tile instanceof TFissionReactor; tile = checkPosition.getTileEntity(this.worldObj)) {
|
|
++checkPosition.y;
|
|
++height;
|
|
}
|
|
|
|
return height;
|
|
}
|
|
|
|
@Override
|
|
public Packet getDescriptionPacket() {
|
|
NBTTagCompound nbt = new NBTTagCompound();
|
|
this.writeToNBT(nbt);
|
|
return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord,
|
|
this.getBlockMetadata(), nbt);
|
|
}
|
|
|
|
private void meltDown() {
|
|
if (!this.worldObj.isRemote) {
|
|
this.setInventorySlotContents(0, (ItemStack) null);
|
|
MegaTNTExplusion baoZha = new MegaTNTExplusion(this.worldObj, (Entity) null, (double) this.xCoord,
|
|
(double) this.yCoord, (double) this.zCoord, 9.0F);
|
|
baoZha.doExplosionA();
|
|
baoZha.doExplosionB(true);
|
|
this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord,
|
|
Blocks.lava);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDataPacket(NetworkManager arg0,
|
|
S35PacketUpdateTileEntity packet) {
|
|
this.readFromNBT(packet.func_148857_g());
|
|
}
|
|
|
|
public void readFromNBT(NBTTagCompound nbt) {
|
|
super.readFromNBT(nbt);
|
|
this.wenDu = nbt.getFloat("temperature");
|
|
this.wasteTank.readFromNBT(nbt.getCompoundTag("tank"));
|
|
NBTTagList items = nbt.getTagList("Items", 10); // 10 = magic number for compound
|
|
this.containingItems = new ItemStack[this.getSizeInventory()];
|
|
|
|
for (int i = 0; i < items.tagCount(); ++i) {
|
|
NBTTagCompound item = items.getCompoundTagAt(i);
|
|
byte var5 = item.getByte("Slot");
|
|
if (var5 >= 0 && var5 < this.containingItems.length) {
|
|
this.containingItems[var5] = ItemStack.loadItemStackFromNBT(item);
|
|
this.containingItems[var5].setItemDamage(item.getInteger("damage"));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound par1NBTTagCompound) {
|
|
super.writeToNBT(par1NBTTagCompound);
|
|
par1NBTTagCompound.setFloat("temperature", this.wenDu);
|
|
NBTTagCompound tankNBT = new NBTTagCompound();
|
|
this.wasteTank.writeToNBT(tankNBT);
|
|
par1NBTTagCompound.setTag("tank", tankNBT);
|
|
NBTTagList var2 = new NBTTagList();
|
|
|
|
for (int var3 = 0; var3 < this.containingItems.length; ++var3) {
|
|
if (this.containingItems[var3] != null) {
|
|
NBTTagCompound var4 = new NBTTagCompound();
|
|
var4.setByte("Slot", (byte) var3);
|
|
this.containingItems[var3].writeToNBT(var4);
|
|
var4.setInteger("damage", this.containingItems[var3].getItemDamage());
|
|
var2.appendTag(var4);
|
|
}
|
|
}
|
|
|
|
par1NBTTagCompound.setTag("Items", var2);
|
|
}
|
|
|
|
@Override
|
|
public int getSizeInventory() {
|
|
return this.containingItems.length;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int par1) {
|
|
return this.containingItems[par1];
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int par1, int par2) {
|
|
if (this.containingItems[par1] != null) {
|
|
ItemStack var3;
|
|
if (this.containingItems[par1].stackSize <= par2) {
|
|
var3 = this.containingItems[par1];
|
|
this.containingItems[par1] = null;
|
|
return var3;
|
|
} else {
|
|
var3 = this.containingItems[par1].splitStack(par2);
|
|
if (this.containingItems[par1].stackSize == 0) {
|
|
this.containingItems[par1] = null;
|
|
}
|
|
|
|
return var3;
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(int par1) {
|
|
if (this.containingItems[par1] != null) {
|
|
ItemStack var2 = this.containingItems[par1];
|
|
this.containingItems[par1] = null;
|
|
return var2;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int par1, ItemStack par2ItemStack) {
|
|
this.containingItems[par1] = par2ItemStack;
|
|
if (par2ItemStack != null &&
|
|
par2ItemStack.stackSize > this.getInventoryStackLimit()) {
|
|
par2ItemStack.stackSize = this.getInventoryStackLimit();
|
|
}
|
|
|
|
this.markDirty();
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) {
|
|
return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this
|
|
? false
|
|
: par1EntityPlayer.getDistanceSq((double) this.xCoord + 0.5D,
|
|
(double) this.yCoord + 0.5D,
|
|
(double) this.zCoord + 0.5D) <= 64.0D;
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {
|
|
}
|
|
|
|
@Override
|
|
public void closeInventory() {
|
|
}
|
|
|
|
@Override
|
|
public void onDisable(int duration) {
|
|
super.disabledTicks = duration;
|
|
}
|
|
|
|
@Override
|
|
public boolean isDisabled() {
|
|
return super.disabledTicks > 0;
|
|
}
|
|
|
|
@Override
|
|
public float getTemperature() {
|
|
return this.wenDu;
|
|
}
|
|
|
|
@Override
|
|
public void setTemperature(float celsius) {
|
|
this.wenDu = Math.max(celsius, 0.0F);
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotID, ItemStack itemStack) {
|
|
return this.cachedZhuYao != null &&
|
|
this.cachedZhuYao.getStackInSlot(0) == null
|
|
? itemStack.getItem() instanceof IFissileMaterial
|
|
: false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill(ForgeDirection arg0, Fluid arg1) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain(ForgeDirection arg0, Fluid arg1) {
|
|
return arg1 == AtomicScience.FLUID_TOXIC_WASTE &&
|
|
this.wasteTank.getFluidAmount() > 0;
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
|
|
return this.wasteTank.drain(maxDrain, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, FluidStack fluid,
|
|
boolean doDrain) {
|
|
return fluid.getFluid() == AtomicScience.FLUID_TOXIC_WASTE
|
|
? this.drain(from, fluid.amount, doDrain)
|
|
: null;
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo(ForgeDirection arg0) {
|
|
return new FluidTankInfo[] { new FluidTankInfo(this.wasteTank) };
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public AxisAlignedBB getRenderBoundingBox() {
|
|
return this.cachedZhuYao == this ? TileEntity.INFINITE_EXTENT_AABB
|
|
: super.getRenderBoundingBox();
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return this.getBlockType().getLocalizedName();
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return false;
|
|
}
|
|
}
|