mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 04:52:25 +00:00
* prevent Out of Bounds exception in factory ItemMeshDefinition * prevent Out of Bounds error in item stack display name * Respect NONE connection between pipes. Fixes #4781 * prevent fluid/gas pipes from connecting if their contents arent the same (part 1) * prevent some case of incorrect network merges that would convert/void a fluid/gas * Add a way to check if a network is compatible with an buffer Used for checking the orphan's buffer against the external network * rename some generic type variables for readability * introduce BUFFER generic type variable * Fix missing null check causing new pipes not being able to be added to a network * More checks for when there is an invalid factory * bump api version & use a constant for all * add default method to not break binary compat * Refresh if a connection exists if a transmitter failed to combine two networks Fallback to the network's buffer as if we have not saved any data yet the TE's buffer may still be null * Add a way to get the pipes buffer falling back to the network, rather than doing it from the same method. This ensures that there is no accidental leakage where the count of the buffer matters * Return a null buffer for pressurized tube buffer if the stack is empty * Allow merging of networks when they are able to connect again Visuals still need a minor update to sync the type it should be rendering * Update network visuals when networks merge * allow unconnected sides to have their mode set - except logistical transporters which already used that function, they only can un-NONE their unconnected sides
314 lines
12 KiB
Java
314 lines
12 KiB
Java
package mekanism.common.tile.transmitter;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.Set;
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.IAlloyInteraction;
|
|
import mekanism.api.transmitters.DynamicNetwork;
|
|
import mekanism.api.transmitters.DynamicNetwork.NetworkClientRequest;
|
|
import mekanism.api.transmitters.IGridTransmitter;
|
|
import mekanism.api.transmitters.TransmitterNetworkRegistry;
|
|
import mekanism.common.capabilities.Capabilities;
|
|
import mekanism.common.transmitters.TransmitterImpl;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.EnumHand;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
import net.minecraftforge.common.capabilities.Capability;
|
|
|
|
public abstract class TileEntityTransmitter<A, N extends DynamicNetwork<A, N, BUFFER>, BUFFER> extends
|
|
TileEntitySidedPipe implements IAlloyInteraction {
|
|
|
|
public TransmitterImpl<A, N, BUFFER> transmitterDelegate;
|
|
|
|
public boolean unloaded = true;
|
|
public boolean dataRequest = false;
|
|
public boolean delayedRefresh = false;
|
|
|
|
private N lastClientNetwork = null;
|
|
|
|
public TileEntityTransmitter() {
|
|
transmitterDelegate = new TransmitterImpl<>(this);
|
|
}
|
|
|
|
public TransmitterImpl<A, N, BUFFER> getTransmitter() {
|
|
return transmitterDelegate;
|
|
}
|
|
|
|
public abstract N createNewNetwork();
|
|
|
|
public abstract N createNetworkByMerging(Collection<N> networks);
|
|
|
|
@Override
|
|
public void onWorldJoin() {
|
|
if (!getWorld().isRemote) {
|
|
TransmitterNetworkRegistry.registerOrphanTransmitter(getTransmitter());
|
|
} else if (lastClientNetwork != null) {
|
|
getTransmitter().setTransmitterNetwork(lastClientNetwork);
|
|
}
|
|
|
|
unloaded = false;
|
|
}
|
|
|
|
@Override
|
|
public void update() {
|
|
super.update();
|
|
|
|
if (delayedRefresh) {
|
|
//Gets run the tick after the variable has been set. This is enough
|
|
// time to ensure that the transmitter has been registered.
|
|
delayedRefresh = false;
|
|
refreshConnections();
|
|
}
|
|
|
|
if (getWorld().isRemote) {
|
|
if (!dataRequest) {
|
|
dataRequest = true;
|
|
MinecraftForge.EVENT_BUS.post(new NetworkClientRequest(getWorld().getTileEntity(getPos())));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onChunkUnload() {
|
|
if (!getWorld().isRemote) {
|
|
getTransmitter().takeShare();
|
|
}
|
|
|
|
super.onChunkUnload();
|
|
}
|
|
|
|
@Override
|
|
public void onWorldSeparate() {
|
|
unloaded = true;
|
|
|
|
if (!getWorld().isRemote) {
|
|
TransmitterNetworkRegistry.invalidateTransmitter(getTransmitter());
|
|
} else {
|
|
lastClientNetwork = getTransmitter().getTransmitterNetwork();
|
|
getTransmitter().setTransmitterNetwork(null);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void markDirtyTransmitters() {
|
|
super.markDirtyTransmitters();
|
|
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
TransmitterNetworkRegistry.invalidateTransmitter(getTransmitter());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void markDirtyAcceptor(EnumFacing side) {
|
|
super.markDirtyAcceptor(side);
|
|
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
getTransmitter().getTransmitterNetwork().acceptorChanged(getTransmitter(), side);
|
|
}
|
|
}
|
|
|
|
protected boolean canHaveIncompatibleNetworks() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected void recheckConnections(byte newlyEnabledTransmitters) {
|
|
if (canHaveIncompatibleNetworks() && getTransmitter().hasTransmitterNetwork()) {
|
|
//We only need to check if we can have incompatible networks and if we actually have a network
|
|
boolean networkUpdated = false;
|
|
for (EnumFacing side : EnumFacing.values()) {
|
|
if (connectionMapContainsSide(newlyEnabledTransmitters, side)) {
|
|
//Recheck the side that is now enabled, as we manually merge this
|
|
// cannot be simplified to a first match is good enough
|
|
networkUpdated |= recheckConnectionPrechecked(side);
|
|
}
|
|
}
|
|
if (networkUpdated) {
|
|
refreshNetwork();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void recheckConnection(EnumFacing side) {
|
|
if (canHaveIncompatibleNetworks() && getTransmitter().hasTransmitterNetwork()) {
|
|
//We only need to check if we can have incompatible networks and if we actually have a network
|
|
if (recheckConnectionPrechecked(side)) {
|
|
refreshNetwork();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void refreshNetwork() {
|
|
//Queue an update for all the transmitters in the network just in case something went wrong
|
|
// and to update the rendering of them
|
|
N network = getTransmitter().getTransmitterNetwork();
|
|
network.queueClientUpdate(network.transmitters);
|
|
//Copy values into a set so that we don't risk a CME
|
|
Set<IGridTransmitter<A, N, BUFFER>> transmitters = new HashSet<>(network.transmitters);
|
|
//TODO: Make some better way of refreshing the connections, given we only need to refresh
|
|
// connections to ourself anyways
|
|
// The best way to do this is probably by making a method that updates the values for
|
|
// the valid transmitters manually if the network is the same object.
|
|
for (IGridTransmitter<A, N, BUFFER> transmitter : transmitters) {
|
|
if (transmitter instanceof TransmitterImpl) {
|
|
//Refresh the connections because otherwise sometimes they need to wait for a block update
|
|
((TransmitterImpl<A, N, BUFFER>) transmitter).containingTile.refreshConnections();
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean recheckConnectionPrechecked(EnumFacing side) {
|
|
N network = getTransmitter().getTransmitterNetwork();
|
|
TileEntity tileEntity = getWorld().getTileEntity(getPos().offset(side));
|
|
if (tileEntity instanceof TileEntityTransmitter) {
|
|
TileEntityTransmitter other = (TileEntityTransmitter) tileEntity;
|
|
//The other one should always have the same incompatible networks state as us
|
|
// But just in case it doesn't just check the boolean
|
|
if (other.canHaveIncompatibleNetworks() && other.getTransmitter().hasTransmitterNetwork()) {
|
|
N otherNetwork = (N) other.getTransmitter().getTransmitterNetwork();
|
|
if (network != otherNetwork && network.isCompatibleWith(otherNetwork)) {
|
|
//We have two networks that are now compatible and they are not the same source network
|
|
// The most common cause they would be same source network is that they would merge
|
|
// from the first pipe checking when it attempts to reconnect, and then the second
|
|
// pipe still is going to be checking the connection.
|
|
|
|
if (getBufferWithFallback() == null) {
|
|
//If we don't have any use them as primary network
|
|
N tempNetwork = network;
|
|
network = otherNetwork;
|
|
otherNetwork = tempNetwork;
|
|
}
|
|
|
|
// Manually merge the networks.
|
|
// This code is not in network registry as there is special handling needed to ensure
|
|
// it visually updates properly. There also were above checks that get us to a certain
|
|
// point where we can make some assumptions about the networks and if it is actually
|
|
// valid to merge them when otherwise people may try to merge things when they shouldn't
|
|
// be merged causing unexpected bugs.
|
|
network.adoptTransmittersAndAcceptorsFrom(otherNetwork);
|
|
//Unregister the other network
|
|
otherNetwork.deregister();
|
|
//Commit the changes of the new network
|
|
network.commit();
|
|
|
|
//We did not have these as part of the update because they got directly added
|
|
// This means that we have to update the capacity/buffer and queue client updates
|
|
// ourselves
|
|
network.updateCapacity();
|
|
network.clampBuffer();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public abstract A getCachedAcceptor(EnumFacing side);
|
|
|
|
protected TileEntity getCachedTile(EnumFacing side) {
|
|
ConnectionType type = connectionTypes[side.ordinal()];
|
|
|
|
if (type == ConnectionType.PULL || type == ConnectionType.NONE) {
|
|
return null;
|
|
}
|
|
|
|
return connectionMapContainsSide(currentAcceptorConnections, side) ? cachedAcceptors[side.ordinal()] : null;
|
|
}
|
|
|
|
@Override
|
|
public void onAlloyInteraction(EntityPlayer player, EnumHand hand, ItemStack stack, int tierOrdinal) {
|
|
if (getTransmitter().hasTransmitterNetwork()) {
|
|
int upgraded = 0;
|
|
Object[] array = ((LinkedHashSet) getTransmitter().getTransmitterNetwork().transmitters.clone()).toArray();
|
|
|
|
Arrays.sort(array, (o1, o2) ->
|
|
{
|
|
if (o1 instanceof IGridTransmitter && o2 instanceof IGridTransmitter) {
|
|
Coord4D thisCoord = new Coord4D(getPos(), getWorld());
|
|
|
|
Coord4D o1Coord = ((IGridTransmitter) o1).coord();
|
|
Coord4D o2Coord = ((IGridTransmitter) o2).coord();
|
|
|
|
return Integer.compare(o1Coord.distanceTo(thisCoord), o2Coord.distanceTo(thisCoord));
|
|
}
|
|
|
|
return 0;
|
|
});
|
|
|
|
for (Object iter : array) {
|
|
if (iter instanceof TransmitterImpl) {
|
|
TileEntityTransmitter t = ((TransmitterImpl) iter).containingTile;
|
|
|
|
if (t.upgrade(tierOrdinal)) {
|
|
upgraded++;
|
|
|
|
if (upgraded == 8) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (upgraded > 0) {
|
|
if (!player.capabilities.isCreativeMode) {
|
|
stack.shrink(1);
|
|
|
|
if (stack.getCount() == 0) {
|
|
player.setHeldItem(hand, ItemStack.EMPTY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean upgrade(int tierOrdinal) {
|
|
return false;
|
|
}
|
|
|
|
public abstract int getCapacity();
|
|
|
|
@Nullable
|
|
public abstract BUFFER getBuffer();
|
|
|
|
@Nullable
|
|
public BUFFER getBufferWithFallback() {
|
|
BUFFER buffer = getBuffer();
|
|
//If we don't have a buffer try falling back to the network's buffer
|
|
if (buffer == null && getTransmitter().hasTransmitterNetwork()) {
|
|
return getTransmitter().getTransmitterNetwork().getBuffer();
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
public abstract void takeShare();
|
|
|
|
public abstract void updateShare();
|
|
|
|
@Override
|
|
public boolean hasCapability(@Nonnull Capability<?> capability, EnumFacing side) {
|
|
return capability == Capabilities.GRID_TRANSMITTER_CAPABILITY
|
|
|| capability == Capabilities.ALLOY_INTERACTION_CAPABILITY
|
|
|| super.hasCapability(capability, side);
|
|
}
|
|
|
|
@Override
|
|
public <T> T getCapability(@Nonnull Capability<T> capability, EnumFacing side) {
|
|
if (capability == Capabilities.GRID_TRANSMITTER_CAPABILITY) {
|
|
return Capabilities.GRID_TRANSMITTER_CAPABILITY.cast(getTransmitter());
|
|
} else if (capability == Capabilities.ALLOY_INTERACTION_CAPABILITY) {
|
|
return Capabilities.ALLOY_INTERACTION_CAPABILITY.cast(this);
|
|
}
|
|
|
|
return super.getCapability(capability, side);
|
|
}
|
|
}
|