mirror of
https://github.com/HbmMods/Hbm-s-Nuclear-Tech-GIT.git
synced 2026-01-25 10:32:49 +00:00
343 lines
8.2 KiB
Java
343 lines
8.2 KiB
Java
package com.hbm.tileentity.machine.oil;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
|
|
import com.hbm.blocks.ModBlocks;
|
|
import com.hbm.inventory.UpgradeManagerNT;
|
|
import com.hbm.inventory.fluid.Fluids;
|
|
import com.hbm.inventory.fluid.tank.FluidTank;
|
|
import com.hbm.items.machine.ItemMachineUpgrade;
|
|
import com.hbm.items.machine.ItemMachineUpgrade.UpgradeType;
|
|
import com.hbm.lib.Library;
|
|
import com.hbm.tileentity.*;
|
|
import com.hbm.util.BobMathUtil;
|
|
import com.hbm.util.Tuple;
|
|
import com.hbm.util.Tuple.Triplet;
|
|
import com.hbm.util.fauxpointtwelve.DirPos;
|
|
|
|
import api.hbm.energymk2.IEnergyReceiverMK2;
|
|
import api.hbm.fluid.IFluidStandardTransceiver;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
public abstract class TileEntityOilDrillBase extends TileEntityMachineBase implements IEnergyReceiverMK2, IFluidStandardTransceiver, IConfigurableMachine, IPersistentNBT, IGUIProvider, IUpgradeInfoProvider, IFluidCopiable {
|
|
|
|
public int indicator = 0;
|
|
|
|
public long power;
|
|
|
|
public FluidTank[] tanks;
|
|
|
|
public UpgradeManagerNT upgradeManager = new UpgradeManagerNT();
|
|
|
|
public TileEntityOilDrillBase() {
|
|
super(8);
|
|
tanks = new FluidTank[2];
|
|
tanks[0] = new FluidTank(Fluids.OIL, 64_000);
|
|
tanks[1] = new FluidTank(Fluids.GAS, 64_000);
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbt) {
|
|
super.readFromNBT(nbt);
|
|
|
|
this.power = nbt.getLong("power");
|
|
for(int i = 0; i < this.tanks.length; i++)
|
|
this.tanks[i].readFromNBT(nbt, "t" + i);
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbt) {
|
|
super.writeToNBT(nbt);
|
|
|
|
nbt.setLong("power", power);
|
|
for(int i = 0; i < this.tanks.length; i++)
|
|
this.tanks[i].writeToNBT(nbt, "t" + i);
|
|
}
|
|
|
|
@Override
|
|
public void writeNBT(NBTTagCompound nbt) {
|
|
|
|
boolean empty = power == 0;
|
|
for(FluidTank tank : tanks) if(tank.getFill() > 0) empty = false;
|
|
|
|
if(!empty) {
|
|
nbt.setLong("power", power);
|
|
for(int i = 0; i < this.tanks.length; i++) {
|
|
this.tanks[i].writeToNBT(nbt, "t" + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readNBT(NBTTagCompound nbt) {
|
|
this.power = nbt.getLong("power");
|
|
for(int i = 0; i < this.tanks.length; i++)
|
|
this.tanks[i].readFromNBT(nbt, "t" + i);
|
|
}
|
|
|
|
public int speedLevel;
|
|
public int energyLevel;
|
|
public int overLevel;
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
|
|
if (!worldObj.isRemote) {
|
|
|
|
this.updateConnections();
|
|
|
|
this.tanks[0].unloadTank(1, 2, slots);
|
|
this.tanks[1].unloadTank(3, 4, slots);
|
|
|
|
upgradeManager.checkSlots(this, slots, 5, 7);
|
|
this.speedLevel = upgradeManager.getLevel(UpgradeType.SPEED);
|
|
this.energyLevel = upgradeManager.getLevel(UpgradeType.POWER);
|
|
this.overLevel = upgradeManager.getLevel(UpgradeType.OVERDRIVE) + 1;
|
|
int abLevel = upgradeManager.getLevel(UpgradeType.AFTERBURN);
|
|
|
|
int toBurn = Math.min(tanks[1].getFill(), abLevel * 10);
|
|
|
|
if (toBurn > 0) {
|
|
tanks[1].setFill(tanks[1].getFill() - toBurn);
|
|
this.power += toBurn * 5;
|
|
|
|
if (this.power > this.getMaxPower())
|
|
this.power = this.getMaxPower();
|
|
}
|
|
|
|
power = Library.chargeTEFromItems(slots, 0, power, this.getMaxPower());
|
|
|
|
for (DirPos pos : getConPos()) {
|
|
if (tanks[0].getFill() > 0)
|
|
this.sendFluid(tanks[0], worldObj, pos.getX(), pos.getY(), pos.getZ(), pos.getDir());
|
|
if (tanks[1].getFill() > 0)
|
|
this.sendFluid(tanks[1], worldObj, pos.getX(), pos.getY(), pos.getZ(), pos.getDir());
|
|
}
|
|
|
|
if (this.power >= this.getPowerReqEff() && this.tanks[0].getFill() < this.tanks[0].getMaxFill() && this.tanks[1].getFill() < this.tanks[1].getMaxFill()) {
|
|
|
|
this.power -= this.getPowerReqEff();
|
|
|
|
if (worldObj.getTotalWorldTime() % getDelayEff() == 0) {
|
|
this.indicator = 0;
|
|
|
|
for (int y = yCoord - 1; y >= getDrillDepth(); y--) {
|
|
|
|
if (worldObj.getBlock(xCoord, y, zCoord) != ModBlocks.oil_pipe) {
|
|
|
|
if (trySuck(y)) {
|
|
break;
|
|
} else {
|
|
tryDrill(y);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (y == getDrillDepth())
|
|
this.indicator = 1;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
this.indicator = 2;
|
|
}
|
|
|
|
this.networkPackNT(25);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void serialize(ByteBuf buf) {
|
|
super.serialize(buf);
|
|
|
|
buf.writeLong(this.power);
|
|
buf.writeInt(this.indicator);
|
|
for (FluidTank tank : tanks) tank.serialize(buf);
|
|
}
|
|
|
|
@Override
|
|
public void deserialize(ByteBuf buf) {
|
|
super.deserialize(buf);
|
|
|
|
this.power = buf.readLong();
|
|
this.indicator = buf.readInt();
|
|
for (FluidTank tank : tanks) tank.deserialize(buf);
|
|
}
|
|
|
|
public boolean canPump() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int i, ItemStack stack) {
|
|
super.setInventorySlotContents(i, stack);
|
|
|
|
if(stack != null && i >= 5 && i <= 7 && stack.getItem() instanceof ItemMachineUpgrade)
|
|
worldObj.playSoundEffect(xCoord + 0.5, yCoord + 1.5, zCoord + 0.5, "hbm:item.upgradePlug", 1.0F, 1.0F);
|
|
}
|
|
|
|
public int getPowerReqEff() {
|
|
int req = this.getPowerReq();
|
|
return (req + (req / 4 * this.speedLevel) - (req / 4 * this.energyLevel)) * this.overLevel;
|
|
}
|
|
|
|
public int getDelayEff() {
|
|
int delay = getDelay();
|
|
return Math.max((delay - (delay / 4 * this.speedLevel) + (delay / 10 * this.energyLevel)) / this.overLevel, 1);
|
|
}
|
|
|
|
public abstract int getPowerReq();
|
|
public abstract int getDelay();
|
|
|
|
public void tryDrill(int y) {
|
|
Block b = worldObj.getBlock(xCoord, y, zCoord);
|
|
|
|
if(b.getExplosionResistance(null) < 1000) {
|
|
onDrill(y);
|
|
worldObj.setBlock(xCoord, y, zCoord, ModBlocks.oil_pipe);
|
|
} else {
|
|
this.indicator = 2;
|
|
}
|
|
}
|
|
|
|
public void onDrill(int y) { }
|
|
|
|
public int getDrillDepth() {
|
|
return 5;
|
|
}
|
|
|
|
public boolean trySuck(int y) {
|
|
|
|
Block b = worldObj.getBlock(xCoord, y, zCoord);
|
|
|
|
if(!canSuckBlock(b))
|
|
return false;
|
|
|
|
if(!this.canPump())
|
|
return true;
|
|
|
|
trace.clear();
|
|
|
|
return suckRec(xCoord, y, zCoord, 0);
|
|
}
|
|
|
|
public boolean canSuckBlock(Block b) {
|
|
return b == ModBlocks.ore_oil || b == ModBlocks.ore_oil_empty;
|
|
}
|
|
|
|
protected HashSet<Tuple.Triplet<Integer, Integer, Integer>> trace = new HashSet();
|
|
|
|
public boolean suckRec(int x, int y, int z, int layer) {
|
|
|
|
Triplet<Integer, Integer, Integer> pos = new Triplet(x, y, z);
|
|
|
|
if(trace.contains(pos))
|
|
return false;
|
|
|
|
trace.add(pos);
|
|
|
|
if(layer > 64)
|
|
return false;
|
|
|
|
Block b = worldObj.getBlock(x, y, z);
|
|
|
|
if(b == ModBlocks.ore_oil || b == ModBlocks.ore_bedrock_oil) {
|
|
doSuck(x, y, z);
|
|
return true;
|
|
}
|
|
|
|
if(b == ModBlocks.ore_oil_empty) {
|
|
ForgeDirection[] dirs = BobMathUtil.getShuffledDirs();
|
|
|
|
for(ForgeDirection dir : dirs) {
|
|
if(suckRec(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ, layer + 1))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void doSuck(int x, int y, int z) {
|
|
|
|
if(worldObj.getBlock(x, y, z) == ModBlocks.ore_oil) {
|
|
onSuck(x, y, z);
|
|
}
|
|
}
|
|
|
|
public abstract void onSuck(int x, int y, int z);
|
|
|
|
@Override
|
|
public void setPower(long i) {
|
|
this.power = i;
|
|
}
|
|
|
|
@Override
|
|
public long getPower() {
|
|
return this.power;
|
|
}
|
|
|
|
@Override
|
|
public AxisAlignedBB getRenderBoundingBox() {
|
|
return TileEntity.INFINITE_EXTENT_AABB;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public double getMaxRenderDistanceSquared() {
|
|
return 65536.0D;
|
|
}
|
|
|
|
@Override
|
|
public FluidTank[] getSendingTanks() {
|
|
return tanks;
|
|
}
|
|
|
|
@Override
|
|
public FluidTank[] getReceivingTanks() {
|
|
return new FluidTank[0];
|
|
}
|
|
|
|
@Override
|
|
public FluidTank[] getAllTanks() {
|
|
return tanks;
|
|
}
|
|
|
|
public abstract DirPos[] getConPos();
|
|
|
|
protected void updateConnections() {
|
|
for(DirPos pos : getConPos()) {
|
|
this.trySubscribe(worldObj, pos.getX(), pos.getY(), pos.getZ(), pos.getDir());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean canProvideInfo(UpgradeType type, int level, boolean extendedInfo) {
|
|
return type == UpgradeType.SPEED || type == UpgradeType.POWER || type == UpgradeType.OVERDRIVE || type == UpgradeType.AFTERBURN;
|
|
}
|
|
|
|
@Override
|
|
public HashMap<UpgradeType, Integer> getValidUpgrades() {
|
|
HashMap<UpgradeType, Integer> upgrades = new HashMap<>();
|
|
upgrades.put(UpgradeType.SPEED, 3);
|
|
upgrades.put(UpgradeType.POWER, 3);
|
|
upgrades.put(UpgradeType.AFTERBURN, 3);
|
|
upgrades.put(UpgradeType.OVERDRIVE, 3);
|
|
return upgrades;
|
|
}
|
|
|
|
@Override
|
|
public FluidTank getTankToPaste() {
|
|
return null;
|
|
}
|
|
}
|