mirror of
https://github.com/GTNewHorizons/EnderIO.git
synced 2026-11-16 18:54:47 +00:00
889 lines
28 KiB
Java
889 lines
28 KiB
Java
package crazypants.enderio.machine.hypercube;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.EnumMap;
|
|
import java.util.List;
|
|
import java.util.ListIterator;
|
|
import java.util.UUID;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.inventory.ISidedInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.MathHelper;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
|
|
import com.enderio.core.common.util.BlockCoord;
|
|
import com.enderio.core.common.util.ItemUtil;
|
|
import com.enderio.core.common.util.PlayerUtil;
|
|
import com.enderio.core.common.vecmath.VecmathUtil;
|
|
|
|
import crazypants.enderio.EnderIO;
|
|
import crazypants.enderio.ModObject;
|
|
import crazypants.enderio.TileEntityEio;
|
|
import crazypants.enderio.config.Config;
|
|
import crazypants.enderio.machine.IRedstoneModeControlable;
|
|
import crazypants.enderio.machine.RedstoneControlMode;
|
|
import crazypants.enderio.network.PacketHandler;
|
|
import crazypants.enderio.power.BasicCapacitor;
|
|
import crazypants.enderio.power.IInternalPowerHandler;
|
|
import crazypants.enderio.power.IPowerInterface;
|
|
import crazypants.enderio.power.PowerHandlerUtil;
|
|
|
|
public class TileHyperCube extends TileEntityEio
|
|
implements IInternalPowerHandler, IFluidHandler, ISidedInventory, IRedstoneModeControlable {
|
|
|
|
private static final double ENERGY_LOSS = Config.transceiverEnergyLoss;
|
|
|
|
private static final int ENERGY_UPKEEP = Config.transceiverUpkeepCostRF;
|
|
|
|
private static final float MILLIBUCKET_TRANSMISSION_COST = Config.transceiverBucketTransmissionCostRF / 1000F;
|
|
|
|
public static enum IoMode {
|
|
|
|
SEND("gui.send"),
|
|
RECIEVE("gui.receive"),
|
|
BOTH("gui.sendReceive"),
|
|
NEITHER("gui.disabled");
|
|
|
|
public static IoMode next(IoMode mode) {
|
|
int index = mode.ordinal() + 1;
|
|
if (index >= values().length) {
|
|
index = 0;
|
|
}
|
|
return values()[index];
|
|
}
|
|
|
|
public static boolean isRecieveEnabled(IoMode mode) {
|
|
return mode == RECIEVE || mode == BOTH;
|
|
}
|
|
|
|
public static boolean isSendEnabled(IoMode mode) {
|
|
return mode == SEND || mode == BOTH;
|
|
}
|
|
|
|
private final String unlocalisedName;
|
|
|
|
private IoMode(String unlocalisedName) {
|
|
this.unlocalisedName = unlocalisedName;
|
|
}
|
|
|
|
public boolean isRecieveEnabled() {
|
|
return isRecieveEnabled(this);
|
|
}
|
|
|
|
public boolean isSendEnabled() {
|
|
return isSendEnabled(this);
|
|
}
|
|
|
|
public IoMode next() {
|
|
return next(this);
|
|
}
|
|
|
|
public String getUnlocalisedName() {
|
|
return unlocalisedName;
|
|
}
|
|
|
|
public String getLocalisedName() {
|
|
return EnderIO.lang.localize(unlocalisedName);
|
|
}
|
|
}
|
|
|
|
public static enum SubChannel {
|
|
POWER,
|
|
FLUID,
|
|
ITEM
|
|
}
|
|
|
|
private final BasicCapacitor internalCapacitor = new BasicCapacitor(Config.transceiverMaxIoRF, 25000);
|
|
|
|
private int lastSyncPowerStored = 0;
|
|
private int storedEnergyRF;
|
|
|
|
private final List<Receptor> receptors = new ArrayList<>();
|
|
private ListIterator<Receptor> receptorIterator = receptors.listIterator();
|
|
private boolean receptorsDirty = true;
|
|
|
|
private final List<NetworkFluidHandler> fluidHandlers = new ArrayList<>();
|
|
private boolean fluidHandlersDirty = true;
|
|
|
|
private CompositeInventory localInventory = new CompositeInventory();
|
|
private boolean inventoriesDirty = true;
|
|
|
|
private Channel channel = null;
|
|
private Channel registeredChannel = null;
|
|
private UUID owner;
|
|
|
|
private static final boolean init = true;
|
|
|
|
private float milliBucketsTransfered = 0;
|
|
|
|
private final EnumMap<SubChannel, IoMode> ioModes = new EnumMap<>(SubChannel.class);
|
|
|
|
private final ItemRecieveBuffer recieveBuffer;
|
|
|
|
protected RedstoneControlMode redstoneControlMode = RedstoneControlMode.IGNORE;
|
|
protected boolean redstoneCheckPassed;
|
|
private boolean redstoneStateDirty = true;
|
|
private boolean isConnected = false;
|
|
|
|
public TileHyperCube() {
|
|
redstoneControlMode = RedstoneControlMode.IGNORE;
|
|
recieveBuffer = new ItemRecieveBuffer(this);
|
|
}
|
|
|
|
@Override
|
|
public RedstoneControlMode getRedstoneControlMode() {
|
|
return redstoneControlMode;
|
|
}
|
|
|
|
@Override
|
|
public void setRedstoneControlMode(RedstoneControlMode redstoneControlMode) {
|
|
this.redstoneControlMode = redstoneControlMode;
|
|
redstoneStateDirty = true;
|
|
updateBlock();
|
|
}
|
|
|
|
public IoMode getModeForChannel(SubChannel channel) {
|
|
IoMode mode = ioModes.get(channel);
|
|
if (mode == null) {
|
|
return IoMode.NEITHER;
|
|
}
|
|
return mode;
|
|
}
|
|
|
|
public void setModeForChannel(SubChannel channel, IoMode mode) {
|
|
ioModes.put(channel, mode);
|
|
}
|
|
|
|
public Channel getChannel() {
|
|
return channel;
|
|
}
|
|
|
|
public void setChannel(Channel channel) {
|
|
this.channel = channel;
|
|
}
|
|
|
|
int getEnergyStoredScaled(int scale) {
|
|
return (int) VecmathUtil
|
|
.clamp(Math.round(scale * ((double) getEnergyStored() / getMaxEnergyStored())), 0, scale);
|
|
}
|
|
|
|
public void onBreakBlock() {
|
|
HyperCubeRegister.instance.deregister(this);
|
|
}
|
|
|
|
public void onBlockAdded() {
|
|
HyperCubeRegister.instance.register(this);
|
|
}
|
|
|
|
public void setOwner(UUID owner) {
|
|
this.owner = owner;
|
|
}
|
|
|
|
private boolean canMaintainConnection() {
|
|
if (channel == null || HyperCubeRegister.instance == null || !redstoneCheckPassed) {
|
|
return false;
|
|
}
|
|
List<TileHyperCube> cons = HyperCubeRegister.instance.getCubesForChannel(channel);
|
|
for (TileHyperCube cube : cons) {
|
|
if (cube != this && cube.getEnergyStored() <= 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return cons != null && cons.size() > 1 && getEnergyStored() > 0;
|
|
}
|
|
|
|
private void sendEnergyToOtherNodes() {
|
|
|
|
List<TileHyperCube> cubes = HyperCubeRegister.instance.getCubesForChannel(channel);
|
|
if (cubes == null || cubes.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (canSendPower()) {
|
|
|
|
for (TileHyperCube cube : cubes) {
|
|
int stored = getEnergyStored();
|
|
if (stored > 0 && cube != null && cube != this && cube.canRecievePower()) {
|
|
int curPower = cube.getEnergyStored();
|
|
int requires = cube.getMaxEnergyStored() - curPower;
|
|
int transfer = Math.min(requires, stored);
|
|
transfer = Math.min(transfer, Config.transceiverMaxIoRF);
|
|
cube.setEnergyStored(curPower + (int) Math.round((1 - ENERGY_LOSS) * transfer));
|
|
setEnergyStored(getEnergyStored() - transfer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload() {
|
|
if (HyperCubeRegister.instance != null) {
|
|
HyperCubeRegister.instance.deregister(this);
|
|
}
|
|
fluidHandlersDirty = true;
|
|
receptorsDirty = true;
|
|
inventoriesDirty = true;
|
|
}
|
|
|
|
public void onNeighborBlockChange() {
|
|
receptorsDirty = true;
|
|
fluidHandlersDirty = true;
|
|
inventoriesDirty = true;
|
|
redstoneStateDirty = true;
|
|
updateInventories();
|
|
}
|
|
|
|
@Override
|
|
public void doUpdate() {
|
|
if (worldObj.isRemote) {
|
|
return;
|
|
} // else is server, do all logic only on the server
|
|
|
|
// Pay upkeep cost
|
|
storedEnergyRF -= ENERGY_UPKEEP;
|
|
// Pay fluid transmission cost
|
|
storedEnergyRF -= (MILLIBUCKET_TRANSMISSION_COST * milliBucketsTransfered);
|
|
|
|
// update power status
|
|
storedEnergyRF = Math.max(storedEnergyRF, 0);
|
|
|
|
milliBucketsTransfered = 0;
|
|
|
|
boolean prevRedCheck = redstoneCheckPassed;
|
|
if (redstoneStateDirty) {
|
|
redstoneCheckPassed = RedstoneControlMode.isConditionMet(redstoneControlMode, this);
|
|
redstoneStateDirty = false;
|
|
}
|
|
|
|
if (!redstoneCheckPassed) {
|
|
if (registeredChannel != null) {
|
|
HyperCubeRegister.instance.deregister(this, registeredChannel);
|
|
registeredChannel = null;
|
|
}
|
|
}
|
|
|
|
if (storedEnergyRF > 0) {
|
|
transmitEnergy();
|
|
sendEnergyToOtherNodes();
|
|
}
|
|
|
|
updateInventories();
|
|
pushRecieveBuffer();
|
|
|
|
// check we are still connected (i.e. we haven't run out of power or started
|
|
// receiving power)
|
|
boolean requiresClientSync = false;
|
|
|
|
boolean stillConnected = canMaintainConnection();
|
|
if (isConnected != stillConnected) {
|
|
fluidHandlersDirty = true;
|
|
isConnected = stillConnected;
|
|
requiresClientSync = true;
|
|
}
|
|
updateFluidHandlers();
|
|
|
|
if (redstoneCheckPassed && (registeredChannel == null ? channel != null : !registeredChannel.equals(channel))) {
|
|
if (registeredChannel != null) {
|
|
HyperCubeRegister.instance.deregister(this, registeredChannel);
|
|
}
|
|
HyperCubeRegister.instance.register(this);
|
|
registeredChannel = channel;
|
|
}
|
|
|
|
requiresClientSync |= prevRedCheck != redstoneCheckPassed;
|
|
|
|
boolean powerChanged = lastSyncPowerStored != storedEnergyRF && shouldDoWorkThisTick(21);
|
|
if (powerChanged) {
|
|
lastSyncPowerStored = storedEnergyRF;
|
|
PacketHandler.sendToAllAround(new PacketStoredPower(this), this);
|
|
}
|
|
|
|
if (requiresClientSync) {
|
|
|
|
// this will cause 'getPacketDescription()' to be called and its result
|
|
// will be sent to the PacketHandler on the other end of
|
|
// client/server connection
|
|
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
|
|
// And this will make sure our current tile entity state is saved
|
|
markDirty();
|
|
}
|
|
}
|
|
|
|
private boolean canSendFluid() {
|
|
return getModeForChannel(SubChannel.FLUID).isSendEnabled();
|
|
}
|
|
|
|
private boolean canSendPower() {
|
|
return getModeForChannel(SubChannel.POWER).isSendEnabled();
|
|
}
|
|
|
|
private boolean canSendItems() {
|
|
return getModeForChannel(SubChannel.ITEM).isSendEnabled() && redstoneCheckPassed;
|
|
}
|
|
|
|
private boolean canRecieveFluid() {
|
|
return getModeForChannel(SubChannel.FLUID).isRecieveEnabled();
|
|
}
|
|
|
|
private boolean canRecievePower() {
|
|
return getModeForChannel(SubChannel.POWER).isRecieveEnabled();
|
|
}
|
|
|
|
private boolean canRecieveItems() {
|
|
return getModeForChannel(SubChannel.ITEM).isRecieveEnabled();
|
|
}
|
|
|
|
// -------------------------- Power -----------------------------------------------
|
|
|
|
private boolean transmitEnergy() {
|
|
|
|
if (!getModeForChannel(SubChannel.POWER).isRecieveEnabled() || !redstoneCheckPassed || getEnergyStored() <= 0) {
|
|
return false;
|
|
}
|
|
|
|
int canTransmit = Math.min(getEnergyStored(), internalCapacitor.getMaxEnergyExtracted());
|
|
int transmitted = 0;
|
|
|
|
updatePowersReceptors();
|
|
|
|
if (!receptors.isEmpty() && !receptorIterator.hasNext()) {
|
|
receptorIterator = receptors.listIterator();
|
|
}
|
|
|
|
int appliedCount = 0;
|
|
int numReceptors = receptors.size();
|
|
while (receptorIterator.hasNext() && canTransmit > 0 && appliedCount < numReceptors) {
|
|
Receptor receptor = receptorIterator.next();
|
|
IPowerInterface pp = receptor.receptor;
|
|
if (pp != null && pp.getMinEnergyReceived(receptor.fromDir.getOpposite()) <= canTransmit) {
|
|
float used = pp.recieveEnergy(receptor.fromDir.getOpposite(), canTransmit);
|
|
transmitted += used;
|
|
canTransmit -= used;
|
|
}
|
|
if (canTransmit <= 0) {
|
|
break;
|
|
}
|
|
|
|
if (!receptors.isEmpty() && !receptorIterator.hasNext()) {
|
|
receptorIterator = receptors.listIterator();
|
|
}
|
|
appliedCount++;
|
|
}
|
|
setEnergyStored(getEnergyStored() - transmitted);
|
|
|
|
return transmitted > 0;
|
|
}
|
|
|
|
// RF Power
|
|
|
|
@Override
|
|
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
|
|
if (getModeForChannel(SubChannel.POWER) != IoMode.RECIEVE) {
|
|
return PowerHandlerUtil.recieveInternal(this, maxReceive, from, simulate);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean canConnectEnergy(ForgeDirection from) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int getEnergyStored(ForgeDirection from) {
|
|
return storedEnergyRF;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyStored(ForgeDirection from) {
|
|
return getMaxEnergyStored();
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyRecieved(ForgeDirection dir) {
|
|
if (getModeForChannel(SubChannel.POWER) == IoMode.RECIEVE) {
|
|
return 0;
|
|
}
|
|
return internalCapacitor.getMaxEnergyReceived();
|
|
}
|
|
|
|
@Override
|
|
public int getEnergyStored() {
|
|
return storedEnergyRF;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxEnergyStored() {
|
|
return internalCapacitor.getMaxEnergyStored();
|
|
}
|
|
|
|
@Override
|
|
public void setEnergyStored(int stored) {
|
|
storedEnergyRF = MathHelper.clamp_int(stored, 0, getMaxEnergyStored());
|
|
}
|
|
|
|
@Override
|
|
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
|
|
if (!canSendFluid()) {
|
|
return 0;
|
|
}
|
|
FluidStack in = resource.copy();
|
|
int result = 0;
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
if (h.node.canRecieveFluid() && h.handler.canFill(h.dirOp, in.getFluid())) {
|
|
int filled = h.handler.fill(h.dirOp, in, doFill);
|
|
in.amount -= filled;
|
|
result += filled;
|
|
}
|
|
}
|
|
if (doFill) {
|
|
milliBucketsTransfered += result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void updatePowersReceptors() {
|
|
if (!receptorsDirty) {
|
|
return;
|
|
}
|
|
receptors.clear();
|
|
BlockCoord myLoc = new BlockCoord(this);
|
|
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
|
|
BlockCoord checkLoc = myLoc.getLocation(dir);
|
|
TileEntity te = worldObj.getTileEntity(checkLoc.x, checkLoc.y, checkLoc.z);
|
|
IPowerInterface pi = PowerHandlerUtil.create(te);
|
|
if (pi != null) {
|
|
receptors.add(new Receptor(pi, dir));
|
|
}
|
|
}
|
|
receptorIterator = receptors.listIterator();
|
|
receptorsDirty = false;
|
|
}
|
|
|
|
// ----------------------- Fluids -----------------------------------------------
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
|
|
if (!canRecieveFluid() || resource == null) {
|
|
return null;
|
|
}
|
|
|
|
FluidStack in = resource.copy();
|
|
FluidStack result = null;
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
if (h.node.canSendFluid() && h.handler.canDrain(h.dirOp, in.getFluid())) {
|
|
FluidStack res = h.handler.drain(h.dirOp, in, false);
|
|
if (res != null) {
|
|
if (result == null) {
|
|
result = res.copy();
|
|
if (doDrain) {
|
|
h.handler.drain(h.dirOp, in, true);
|
|
}
|
|
|
|
} else if (result.isFluidEqual(res)) {
|
|
result.amount += res.amount;
|
|
if (doDrain) {
|
|
h.handler.drain(h.dirOp, in, true);
|
|
}
|
|
in.amount -= res.amount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain(ForgeDirection from, int maxDrainIn, boolean doDrain) {
|
|
if (!canRecieveFluid()) {
|
|
return null;
|
|
}
|
|
int maxDrain = maxDrainIn;
|
|
FluidStack result = null;
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
if (h.node.canSendFluid()) {
|
|
FluidStack res = h.handler.drain(h.dirOp, maxDrain, false);
|
|
if (res != null) {
|
|
if (result == null) {
|
|
result = res.copy();
|
|
if (doDrain) {
|
|
h.handler.drain(h.dirOp, maxDrain, true);
|
|
}
|
|
maxDrain -= res.amount;
|
|
} else if (result.isFluidEqual(res)) {
|
|
result.amount += res.amount;
|
|
if (doDrain) {
|
|
h.handler.drain(h.dirOp, maxDrain, true);
|
|
}
|
|
maxDrain -= res.amount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill(ForgeDirection from, Fluid fluid) {
|
|
if (!canSendFluid()) {
|
|
return false;
|
|
}
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
if (h.node.canRecieveFluid()) {
|
|
if (h.handler.canFill(h.dirOp, fluid)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain(ForgeDirection from, Fluid fluid) {
|
|
if (!canRecieveFluid()) {
|
|
return false;
|
|
}
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
if (h.node.canSendFluid()) {
|
|
if (h.handler.canDrain(h.dirOp, fluid)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo(ForgeDirection from) {
|
|
List<FluidTankInfo> res = new ArrayList<>();
|
|
for (NetworkFluidHandler h : getNetworkHandlers()) {
|
|
FluidTankInfo[] ti = h.handler.getTankInfo(h.dirOp);
|
|
if (ti != null) {
|
|
for (FluidTankInfo t : ti) {
|
|
if (t != null) {
|
|
res.add(t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (res.isEmpty()) {
|
|
return new FluidTankInfo[] { new FluidTankInfo(null, 0) };
|
|
} else {
|
|
return res.toArray(new FluidTankInfo[res.size()]);
|
|
}
|
|
}
|
|
|
|
private List<NetworkFluidHandler> getNetworkHandlers() {
|
|
if (HyperCubeRegister.instance == null || !redstoneCheckPassed) {
|
|
return Collections.emptyList();
|
|
}
|
|
List<TileHyperCube> cubes = HyperCubeRegister.instance.getCubesForChannel(channel);
|
|
if (cubes == null || cubes.isEmpty()) {
|
|
return Collections.emptyList();
|
|
}
|
|
List<NetworkFluidHandler> result = new ArrayList<>();
|
|
for (TileHyperCube cube : cubes) {
|
|
if (cube != this && cube != null) {
|
|
List<NetworkFluidHandler> handlers = cube.fluidHandlers;
|
|
if (handlers != null && !handlers.isEmpty()) {
|
|
result.addAll(handlers);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void updateFluidHandlers() {
|
|
if (!fluidHandlersDirty) {
|
|
return;
|
|
}
|
|
fluidHandlers.clear();
|
|
if (isConnected) {
|
|
BlockCoord myLoc = new BlockCoord(this);
|
|
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
|
|
BlockCoord checkLoc = myLoc.getLocation(dir);
|
|
TileEntity te = worldObj.getTileEntity(checkLoc.x, checkLoc.y, checkLoc.z);
|
|
if (te instanceof IFluidHandler && !(te instanceof TileHyperCube)) {
|
|
IFluidHandler fh = (IFluidHandler) te;
|
|
fluidHandlers.add(new NetworkFluidHandler(this, fh, dir));
|
|
}
|
|
}
|
|
fluidHandlersDirty = false;
|
|
}
|
|
}
|
|
|
|
// ------- Item / Inventory ---------------------------------------------------------------------
|
|
|
|
public ItemRecieveBuffer getRecieveBuffer() {
|
|
return recieveBuffer;
|
|
}
|
|
|
|
private void updateInventories() {
|
|
|
|
recieveBuffer.setRecieveEnabled(canSendItems());
|
|
|
|
if (!inventoriesDirty) {
|
|
return;
|
|
}
|
|
|
|
localInventory = new CompositeInventory();
|
|
|
|
BlockCoord myLoc = new BlockCoord(this);
|
|
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
|
|
BlockCoord checkLoc = myLoc.getLocation(dir);
|
|
TileEntity te = worldObj.getTileEntity(checkLoc.x, checkLoc.y, checkLoc.z);
|
|
if (te instanceof IInventory && !(te instanceof TileHyperCube)) {
|
|
localInventory.addInventory((IInventory) te, dir);
|
|
}
|
|
}
|
|
inventoriesDirty = false;
|
|
}
|
|
|
|
void pushRecieveBuffer() {
|
|
|
|
if (recieveBuffer.isEmpty()) {
|
|
return;
|
|
}
|
|
List<TileHyperCube> cubes = HyperCubeRegister.instance.getCubesForChannel(channel);
|
|
if (cubes == null || cubes.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < recieveBuffer.getSizeInventory(); i++) {
|
|
ItemStack toPush = recieveBuffer.getStackInSlot(i);
|
|
if (toPush != null) {
|
|
for (TileHyperCube cube : cubes) {
|
|
if (toPush != null && cube != this && cube != null && cube.canRecieveItems()) {
|
|
toPush = cube.recieveItems(toPush);
|
|
recieveBuffer.getItems()[i] = toPush;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ItemStack recieveItems(ItemStack toPush) {
|
|
if (toPush == null) {
|
|
return null;
|
|
}
|
|
ItemStack result = toPush.copy();
|
|
// TODO: need to cache this
|
|
BlockCoord myLoc = new BlockCoord(this);
|
|
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
|
|
BlockCoord checkLoc = myLoc.getLocation(dir);
|
|
TileEntity te = worldObj.getTileEntity(checkLoc.x, checkLoc.y, checkLoc.z);
|
|
result.stackSize -= ItemUtil.doInsertItem(te, result, dir.getOpposite());
|
|
if (result.stackSize <= 0) {
|
|
return null;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private ISidedInventory getRemoteInventory() {
|
|
|
|
CompositeInventory res = new CompositeInventory();
|
|
res.addInventory(recieveBuffer, ForgeDirection.UNKNOWN);
|
|
|
|
if (!canSendItems()) {
|
|
return res;
|
|
}
|
|
|
|
if (HyperCubeRegister.instance == null) {
|
|
return res;
|
|
}
|
|
List<TileHyperCube> cubes = HyperCubeRegister.instance.getCubesForChannel(channel);
|
|
if (cubes == null || cubes.isEmpty()) {
|
|
return res;
|
|
}
|
|
for (TileHyperCube cube : cubes) {
|
|
if (cube != this && cube != null && cube.canRecieveItems()) {
|
|
if (cube.inventoriesDirty) {
|
|
cube.updateInventories();
|
|
}
|
|
res.addInventory(cube.localInventory);
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
@Override
|
|
public int getSizeInventory() {
|
|
return getRemoteInventory().getSizeInventory();
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int i) {
|
|
return getRemoteInventory().getStackInSlot(i);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int i, int j) {
|
|
return getRemoteInventory().decrStackSize(i, j);
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int i, ItemStack itemstack) {
|
|
getRemoteInventory().setInventorySlotContents(i, itemstack);
|
|
}
|
|
|
|
@Override
|
|
public int[] getAccessibleSlotsFromSide(int var1) {
|
|
return getRemoteInventory().getAccessibleSlotsFromSide(var1);
|
|
}
|
|
|
|
@Override
|
|
public boolean canInsertItem(int i, ItemStack itemstack, int j) {
|
|
return getRemoteInventory().canInsertItem(i, itemstack, j);
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtractItem(int i, ItemStack itemstack, int j) {
|
|
return getRemoteInventory().canExtractItem(i, itemstack, j);
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int i, ItemStack itemstack) {
|
|
return getRemoteInventory().isItemValidForSlot(i, itemstack);
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return ModObject.blockHyperCube.unlocalisedName;
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return 64;
|
|
}
|
|
|
|
@Override
|
|
public boolean isUseableByPlayer(EntityPlayer entityplayer) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {}
|
|
|
|
@Override
|
|
public void closeInventory() {}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(int i) {
|
|
return null;
|
|
}
|
|
|
|
// ---- Serialisation ---------------------------------------------------------
|
|
|
|
@Override
|
|
public void readCustomNBT(NBTTagCompound nbtRoot) {
|
|
|
|
int energy;
|
|
if (nbtRoot.hasKey("storedEnergy")) {
|
|
energy = (int) (nbtRoot.getFloat("storedEnergy") * 10);
|
|
} else {
|
|
energy = nbtRoot.getInteger("storedEnergyRF");
|
|
}
|
|
setEnergyStored(energy);
|
|
|
|
String channelName = nbtRoot.getString("channelName");
|
|
UUID channelUser = PlayerUtil.getPlayerUIDUnstable(nbtRoot.getString("channelUser"));
|
|
if (channelName != null && !channelName.isEmpty()) {
|
|
channel = new Channel(channelName, channelUser);
|
|
} else {
|
|
channel = null;
|
|
}
|
|
|
|
owner = PlayerUtil.getPlayerUIDUnstable(nbtRoot.getString("owner"));
|
|
|
|
for (SubChannel subChannel : SubChannel.values()) {
|
|
String key = "subChannel" + subChannel.ordinal();
|
|
if (nbtRoot.hasKey(key)) {
|
|
setModeForChannel(subChannel, IoMode.values()[nbtRoot.getShort(key)]);
|
|
}
|
|
}
|
|
|
|
recieveBuffer.readFromNBT(nbtRoot);
|
|
|
|
if (nbtRoot.hasKey("rsMode")) {
|
|
redstoneControlMode = RedstoneControlMode.VALUES[nbtRoot.getShort("rsMode")];
|
|
} else {
|
|
redstoneControlMode = RedstoneControlMode.IGNORE;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeCustomNBT(NBTTagCompound nbtRoot) {
|
|
nbtRoot.setInteger("storedEnergyRF", storedEnergyRF);
|
|
if (channel != null) {
|
|
nbtRoot.setString("channelName", channel.name);
|
|
if (channel.user != null) {
|
|
nbtRoot.setString("channelUser", channel.user.toString());
|
|
}
|
|
}
|
|
if (owner != null) {
|
|
nbtRoot.setString("owner", owner.toString());
|
|
}
|
|
|
|
for (SubChannel subChannel : SubChannel.values()) {
|
|
IoMode mode = getModeForChannel(subChannel);
|
|
nbtRoot.setShort("subChannel" + subChannel.ordinal(), (short) mode.ordinal());
|
|
}
|
|
if (redstoneControlMode != null) {
|
|
nbtRoot.setShort("rsMode", (short) redstoneControlMode.ordinal());
|
|
}
|
|
recieveBuffer.writeToNBT(nbtRoot);
|
|
}
|
|
|
|
static class Receptor {
|
|
|
|
IPowerInterface receptor;
|
|
ForgeDirection fromDir;
|
|
|
|
private Receptor(IPowerInterface rec, ForgeDirection fromDir) {
|
|
receptor = rec;
|
|
this.fromDir = fromDir;
|
|
}
|
|
}
|
|
|
|
static class NetworkFluidHandler {
|
|
|
|
final TileHyperCube node;
|
|
final IFluidHandler handler;
|
|
final ForgeDirection dir;
|
|
final ForgeDirection dirOp;
|
|
|
|
private NetworkFluidHandler(TileHyperCube node, IFluidHandler handler, ForgeDirection dir) {
|
|
this.node = node;
|
|
this.handler = handler;
|
|
this.dir = dir;
|
|
dirOp = dir.getOpposite();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean displayPower() {
|
|
return true;
|
|
}
|
|
}
|