diff options
Diffstat (limited to 'src/Java/miscutil/core/multiblock')
17 files changed, 1208 insertions, 0 deletions
diff --git a/src/Java/miscutil/core/multiblock/abstracts/AbstractFakeMultiblockController.java b/src/Java/miscutil/core/multiblock/abstracts/AbstractFakeMultiblockController.java new file mode 100644 index 0000000000..1fc74a37a7 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/AbstractFakeMultiblockController.java @@ -0,0 +1,68 @@ +package miscutil.core.multiblock.abstracts; + +import miscutil.core.multiblock.abstracts.interfaces.IAbstractControllerInternal; +import miscutil.core.multiblock.base.BaseFakeMultiblockController; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockController; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.biome.BiomeGenBase; + +import com.mojang.authlib.GameProfile; + +public class AbstractFakeMultiblockController +extends BaseFakeMultiblockController +implements IAbstractControllerInternal +{ + public static final AbstractFakeMultiblockController instance = new AbstractFakeMultiblockController(); + + + public int getBlockLightValue() + { + return 0; + } + + public boolean canBlockSeeTheSky() + { + return false; + } + + public GameProfile getOwner() + { + return null; + } + + public ChunkCoordinates getCoordinates() + { + return null; + } + + public BiomeGenBase getBiome() + { + return null; + } + + @Override + public void assimilate( + IBaseMultiblockController paramIMultiblockControllerInternal) { + } + + @Override + public void _onAssimilated( + IBaseMultiblockController paramIMultiblockControllerInternal) { + } + + @Override + public void onAssimilated( + IBaseMultiblockController paramIMultiblockControllerInternal) { + } + + @Override + public boolean shouldConsume( + IBaseMultiblockController paramIMultiblockControllerInternal) { + return false; + } + + @Override + public int getHealthScaled(int paramInt) { + return 0; + } +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockController.java b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockController.java new file mode 100644 index 0000000000..2ebcea7ce8 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockController.java @@ -0,0 +1,213 @@ +package miscutil.core.multiblock.abstracts; + +import java.util.Collection; + +import miscutil.core.multiblock.abstracts.interfaces.IAbstractControllerInternal; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockController; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import raisintoast.core.common.CoordTriplet; +import raisintoast.core.multiblock.IMultiblockPart; +import raisintoast.core.multiblock.MultiblockControllerBase; +import raisintoast.core.multiblock.rectangular.RectangularMultiblockControllerBase; + + +public class AbstractMultiblockController extends RectangularMultiblockControllerBase implements IAbstractControllerInternal { + + protected AbstractMultiblockController(World world) { + super(world); + // TODO Auto-generated constructor stub + } + + @Override + public void decodeDescriptionPacket(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void formatDescriptionPacket(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + protected int getMaximumXSize() { + // TODO Auto-generated method stub + return 0; + } + + @Override + protected int getMaximumYSize() { + // TODO Auto-generated method stub + return 0; + } + + @Override + protected int getMaximumZSize() { + // TODO Auto-generated method stub + return 0; + } + + @Override + protected int getMinimumNumberOfBlocksForAssembledMachine() { + // TODO Auto-generated method stub + return 0; + } + + @Override + protected void onAssimilate(MultiblockControllerBase arg0) { + // TODO Auto-generated method stub + + } + + @Override + protected void onAssimilated(MultiblockControllerBase arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void onAttachedPartWithMultiblockData(IMultiblockPart arg0, + NBTTagCompound arg1) { + // TODO Auto-generated method stub + + } + + @Override + protected void onBlockAdded(IMultiblockPart arg0) { + // TODO Auto-generated method stub + + } + + @Override + protected void onBlockRemoved(IMultiblockPart arg0) { + // TODO Auto-generated method stub + + } + + @Override + protected void onMachineAssembled() { + // TODO Auto-generated method stub + + } + + @Override + protected void onMachineDisassembled() { + // TODO Auto-generated method stub + + } + + @Override + protected void onMachinePaused() { + // TODO Auto-generated method stub + + } + + @Override + protected void onMachineRestored() { + // TODO Auto-generated method stub + + } + + @Override + public void readFromNBT(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + protected void updateClient() { + // TODO Auto-generated method stub + + } + + @Override + protected boolean updateServer() { + // TODO Auto-generated method stub + return false; + } + + @Override + public void writeToNBT(NBTTagCompound arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void reassemble() { + // TODO Auto-generated method stub + + } + + @Override + public String getLastValidationError() { + // TODO Auto-generated method stub + return null; + } + + @Override + public Collection<IMultiblockPart> getComponents() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void assimilate( + IBaseMultiblockController paramIMultiblockControllerInternal) { + // TODO Auto-generated method stub + + } + + @Override + public void _onAssimilated( + IBaseMultiblockController paramIMultiblockControllerInternal) { + // TODO Auto-generated method stub + + } + + @Override + public void onAssimilated( + IBaseMultiblockController paramIMultiblockControllerInternal) { + // TODO Auto-generated method stub + + } + + @Override + public CoordTriplet getReferenceCoord() { + // TODO Auto-generated method stub + return null; + } + + @Override + public World getWorld() { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean shouldConsume( + IBaseMultiblockController paramIMultiblockControllerInternal) { + // TODO Auto-generated method stub + return false; + } + + @Override + public String getPartsListString() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void auditParts() { + // TODO Auto-generated method stub + + } + + @Override + public int getHealthScaled(int paramInt) { + // TODO Auto-generated method stub + return 0; + } + +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockLogic.java b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockLogic.java new file mode 100644 index 0000000000..c2c92e83d2 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockLogic.java @@ -0,0 +1,31 @@ +package miscutil.core.multiblock.abstracts; + +import miscutil.core.multiblock.abstracts.interfaces.IAbstractControllerInternal; +import miscutil.core.multiblock.abstracts.interfaces.IAbstractMultiblockLogic; +import miscutil.core.multiblock.base.BaseMultiblockLogic; +import net.minecraft.world.World; + +public class AbstractMultiblockLogic extends BaseMultiblockLogic<IAbstractControllerInternal> implements IAbstractMultiblockLogic +{ + public AbstractMultiblockLogic() + { + super(IAbstractControllerInternal.class); + } + + @Override +public IAbstractControllerInternal getController() + { + if (super.isConnected()) { + return (IAbstractControllerInternal)this.controller; + } + return AbstractFakeMultiblockController.instance; + } + + @Override +public IAbstractControllerInternal createNewController(World world) + { + return new AbstractMultiblockController(world); + } + + +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockSizeLimits.java b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockSizeLimits.java new file mode 100644 index 0000000000..e7675bb31e --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockSizeLimits.java @@ -0,0 +1,69 @@ +package miscutil.core.multiblock.abstracts; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockSizeLimits; + +public class AbstractMultiblockSizeLimits implements IBaseMultiblockSizeLimits { + + public static final AbstractMultiblockSizeLimits instance = new AbstractMultiblockSizeLimits(3,3,3,3,3,3,27); + + private short min_X; + private short min_Y; + private short min_Z; + private short max_X; + private short max_Y; + private short max_Z; + private short totalBlocks; + + public AbstractMultiblockSizeLimits(int min_x, int min_y, int min_z, int max_x, int max_y, int max_z, int totalSize){ + this.min_X = (short) min_x; + this.min_Y = (short) min_y; + this.min_Z = (short) min_z; + this.max_X = (short) max_x; + this.max_Y = (short) max_y; + this.max_Z = (short) max_z; + this.totalBlocks = (short) totalSize; + } + + + @Override + public int getMinNumberOfBlocksForAssembledMachine() + { + return totalBlocks; + } + + @Override + public int getMaxXSize() + { + return max_X; + } + + @Override + public int getMaxZSize() + { + return max_Y; + } + + @Override + public int getMaxYSize() + { + return max_Z; + } + + @Override + public int getMinXSize() + { + return min_X; + } + + @Override + public int getMinYSize() + { + return min_Y; + } + + @Override + public int getMinZSize() + { + return min_Z; + } +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockTE.java b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockTE.java new file mode 100644 index 0000000000..ada934f2b1 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/AbstractMultiblockTE.java @@ -0,0 +1,194 @@ +package miscutil.core.multiblock.abstracts; + + +import miscutil.core.handler.GuiHandler; +import miscutil.core.multiblock.abstracts.interfaces.IAbstractMultiblockLogic; +import miscutil.core.multiblock.base.BaseMultiblockTE; +import miscutil.core.xmod.forestry.core.inventory.FakeInventoryAdapter; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTUtil; +import net.minecraft.world.World; + +import com.mojang.authlib.GameProfile; + +public abstract class AbstractMultiblockTE<T extends IAbstractMultiblockLogic> +extends BaseMultiblockTE<T> implements ISidedInventory { + + private GameProfile owner; + + public AbstractMultiblockTE(T multiblockLogic) + { + super(multiblockLogic); + } + + public void openGui(EntityPlayer player) + { + GuiHandler.openGui(player, this); + } + + @Override + public void readFromNBT(NBTTagCompound data) + { + super.readFromNBT(data); + if (data.hasKey("owner")) { + this.owner = NBTUtil.func_152459_a(data.getCompoundTag("owner")); + } + getInternalInventory().readFromNBT(data); + } + + @Override + public void writeToNBT(NBTTagCompound data) + { + super.writeToNBT(data); + if (this.owner != null) + { + NBTTagCompound nbt = new NBTTagCompound(); + NBTUtil.func_152460_a(nbt, this.owner); + data.setTag("owner", nbt); + } + getInternalInventory().writeToNBT(data); + } + + public FakeInventoryAdapter getInternalInventory() + { + return FakeInventoryAdapter.instance(); + } + + public boolean allowsAutomation() + { + return false; + } + + @Override + public final int getSizeInventory() + { + return getInternalInventory().getSizeInventory(); + } + + @Override + public final ItemStack getStackInSlot(int slotIndex) + { + return getInternalInventory().getStackInSlot(slotIndex); + } + + @Override + public final ItemStack decrStackSize(int slotIndex, int amount) + { + return getInternalInventory().decrStackSize(slotIndex, amount); + } + + @Override + public final ItemStack getStackInSlotOnClosing(int slotIndex) + { + return getInternalInventory().getStackInSlotOnClosing(slotIndex); + } + + @Override + public final void setInventorySlotContents(int slotIndex, ItemStack itemstack) + { + getInternalInventory().setInventorySlotContents(slotIndex, itemstack); + } + + @Override + public final int getInventoryStackLimit() + { + return getInternalInventory().getInventoryStackLimit(); + } + + @Override + public final void openInventory() + { + getInternalInventory().openInventory(); + } + + @Override + public final void closeInventory() + { + getInternalInventory().closeInventory(); + } + + @Override + public final String getInventoryName() + { + return getInternalInventory().getInventoryName(); + } + + @Override + public final boolean isUseableByPlayer(EntityPlayer player) + { + return getInternalInventory().isUseableByPlayer(player); + } + + @Override + public final boolean hasCustomInventoryName() + { + return getInternalInventory().hasCustomInventoryName(); + } + + @Override + public final boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) + { + return getInternalInventory().isItemValidForSlot(slotIndex, itemStack); + } + + @Override + public final int[] getAccessibleSlotsFromSide(int side) + { + if (allowsAutomation()) { + return getAccessibleSlotsFromSide(side); + } + return FakeInventoryAdapter.SLOTS_NONE; + } + + @Override + public final boolean canInsertItem(int slotIndex, ItemStack itemStack, int side) + { + if (allowsAutomation()) { + return canInsertItem(slotIndex, itemStack, side); + } + return false; + } + + @Override + public final boolean canExtractItem(int slotIndex, ItemStack itemStack, int side) + { + if (allowsAutomation()) { + return getInternalInventory().canExtractItem(slotIndex, itemStack, side); + } + return false; + } + + @Override + public final boolean canSlotAccept(int slotIndex, ItemStack itemStack) + { + return getInternalInventory().canSlotAccept(slotIndex, itemStack); + } + + @Override + public final boolean isLocked(int slotIndex) + { + return getInternalInventory().isLocked(slotIndex); + } + + @Override + public final World getWorld() + { + return this.worldObj; + } + + public final GameProfile getOwner() + { + return this.owner; + } + + public final void setOwner(GameProfile owner) + { + this.owner = owner; + } + + + +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractController.java b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractController.java new file mode 100644 index 0000000000..2780cc1305 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractController.java @@ -0,0 +1,7 @@ +package miscutil.core.multiblock.abstracts.interfaces; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockController; + +public abstract interface IAbstractController extends IBaseMultiblockController { + +} diff --git a/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractControllerInternal.java b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractControllerInternal.java new file mode 100644 index 0000000000..3e1638cda8 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractControllerInternal.java @@ -0,0 +1,9 @@ +package miscutil.core.multiblock.abstracts.interfaces; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockControllerInternal; + +public interface IAbstractControllerInternal extends IAbstractController, IBaseMultiblockControllerInternal { + //public abstract IInventoryAdapter getInternalInventory(); + + public abstract int getHealthScaled(int paramInt); + }
\ No newline at end of file diff --git a/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractMultiblockLogic.java b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractMultiblockLogic.java new file mode 100644 index 0000000000..aacb3c290d --- /dev/null +++ b/src/Java/miscutil/core/multiblock/abstracts/interfaces/IAbstractMultiblockLogic.java @@ -0,0 +1,11 @@ +package miscutil.core.multiblock.abstracts.interfaces; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockLogic; + +public abstract interface IAbstractMultiblockLogic extends IBaseMultiblockLogic { + +@Override +public abstract IAbstractController getController(); + +} + diff --git a/src/Java/miscutil/core/multiblock/base/BaseFakeMultiblockController.java b/src/Java/miscutil/core/multiblock/base/BaseFakeMultiblockController.java new file mode 100644 index 0000000000..e4de47267c --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/BaseFakeMultiblockController.java @@ -0,0 +1,123 @@ +package miscutil.core.multiblock.base; + +import java.util.Collection; +import java.util.Collections; +import java.util.Set; + +import javax.annotation.Nonnull; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockControllerInternal; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import raisintoast.core.common.CoordTriplet; +import raisintoast.core.multiblock.IMultiblockPart; + +public abstract class BaseFakeMultiblockController +implements IBaseMultiblockControllerInternal +{ + @Override + public void attachBlock(IMultiblockPart part) {} + + @Override + public void detachBlock(IMultiblockPart part, boolean chunkUnloading) {} + + @Override + public void checkIfMachineIsWhole() {} + + public void assimilate(IBaseMultiblockControllerInternal other) {} + + public void _onAssimilated(IBaseMultiblockControllerInternal otherController) {} + + public void onAssimilated(IBaseMultiblockControllerInternal assimilator) {} + + @Override + public void updateMultiblockEntity() {} + + @Override + public CoordTriplet getReferenceCoord() + { + return null; + } + + @Override + public void recalculateMinMaxCoords() {} + + @Override + public void formatDescriptionPacket(NBTTagCompound data) {} + + @Override + public void decodeDescriptionPacket(NBTTagCompound data) {} + + @Override + public World getWorld() + { + return null; + } + + @Override + public boolean isEmpty() + { + return true; + } + + public boolean shouldConsume(IBaseMultiblockControllerInternal otherController) + { + return false; + } + + @Override + public String getPartsListString() + { + return ""; + } + + @Override + public void auditParts() {} + + @Override + @Nonnull + public Set<IMultiblockPart> checkForDisconnections() + { + return Collections.emptySet(); + } + + @Override + @Nonnull + public Set<IMultiblockPart> detachAllBlocks() + { + return Collections.emptySet(); + } + + @Override + public boolean isAssembled() + { + return false; + } + + @Override + public void reassemble() {} + + @Override + public String getLastValidationError() + { + return null; + } + + @Override + @Nonnull + public Collection<IMultiblockPart> getComponents() + { + return Collections.emptyList(); + } + + public void readFromNBT(NBTTagCompound nbttagcompound) { + + } + + public void writeToNBT(NBTTagCompound nbttagcompound) { + + } + + + +} diff --git a/src/Java/miscutil/core/multiblock/base/BaseMultiblockLogic.java b/src/Java/miscutil/core/multiblock/base/BaseMultiblockLogic.java new file mode 100644 index 0000000000..1812918109 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/BaseMultiblockLogic.java @@ -0,0 +1,184 @@ +package miscutil.core.multiblock.base; + +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockComponent; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockControllerInternal; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockLogic; +import miscutil.core.util.Utils; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; +import raisintoast.core.multiblock.IMultiblockPart; +import raisintoast.core.multiblock.MultiblockRegistry; + +public abstract class BaseMultiblockLogic<T extends IBaseMultiblockControllerInternal> +implements IBaseMultiblockLogic +{ + private final Class<T> controllerClass; + private boolean visited; + private boolean saveMultiblockData; + private NBTTagCompound cachedMultiblockData; + protected T controller; + + protected BaseMultiblockLogic(Class<T> controllerClass) + { + this.controllerClass = controllerClass; + this.controller = null; + this.visited = false; + this.saveMultiblockData = false; + this.cachedMultiblockData = null; + } + + public void setController(T controller) + { + if (controller == null) { + this.controller = null; + } else if (this.controllerClass.isAssignableFrom(controller.getClass())) { + this.controller = (this.controllerClass.cast(controller)); + } + } + + public Class<T> getControllerClass() + { + return this.controllerClass; + } + + @Override + public abstract T getController(); + + public abstract T createNewController(World paramWorld); + + @Override + public void validate(World world, IMultiblockPart part) + { + MultiblockRegistry.onPartAdded(world, part); + } + + @Override + public final void invalidate(World world, IMultiblockPart part) + { + detachSelf(world, part, false); + } + + @Override + public final void onChunkUnload(World world, IMultiblockPart part) + { + detachSelf(world, part, true); + } + + protected void detachSelf(World world, IMultiblockPart part, boolean chunkUnloading) + { + if (this.controller != null) + { + this.controller.detachBlock(part, chunkUnloading); + + + this.controller = null; + } + MultiblockRegistry.onPartRemovedFromWorld(world, part); + } + + @Override + public void readFromNBT(NBTTagCompound data) + { + if (data.hasKey("multiblockData")) { + this.cachedMultiblockData = data.getCompoundTag("multiblockData"); + } + } + + @Override + public void writeToNBT(NBTTagCompound data) + { + if ((isMultiblockSaveDelegate()) && (isConnected())) + { + NBTTagCompound multiblockData = new NBTTagCompound(); + ((IBaseMultiblockLogic) this.controller).writeToNBT(multiblockData); + data.setTag("multiblockData", multiblockData); + } + } + + public final void assertDetached(IBaseMultiblockComponent part) + { + if (this.controller != null) + { + ChunkCoordinates coords = part.getCoordinates(); + Utils.LOG_INFO("[assert] Part @ (%d, %d, %d) should be detached already, but detected that it was not. This is not a fatal error, and will be repaired, but is unusual. " + String.valueOf(new Object[] { Integer.valueOf(coords.posX), Integer.valueOf(coords.posY), Integer.valueOf(coords.posZ) })); + this.controller = null; + } + } + + @Override + public final boolean isConnected() + { + return this.controller != null; + } + + public final void becomeMultiblockSaveDelegate() + { + this.saveMultiblockData = true; + } + + public final void forfeitMultiblockSaveDelegate() + { + this.saveMultiblockData = false; + } + + public final boolean isMultiblockSaveDelegate() + { + return this.saveMultiblockData; + } + + public final void setUnvisited() + { + this.visited = false; + } + + public final void setVisited() + { + this.visited = true; + } + + public final boolean isVisited() + { + return this.visited; + } + + public final boolean hasMultiblockSaveData() + { + return this.cachedMultiblockData != null; + } + + public final NBTTagCompound getMultiblockSaveData() + { + return this.cachedMultiblockData; + } + + public final void onMultiblockDataAssimilated() + { + this.cachedMultiblockData = null; + } + + @Override + public void encodeDescriptionPacket(NBTTagCompound packetData) + { + if ((isMultiblockSaveDelegate()) && (isConnected())) + { + NBTTagCompound tag = new NBTTagCompound(); + this.controller.formatDescriptionPacket(tag); + packetData.setTag("multiblockData", tag); + } + } + + @Override + public void decodeDescriptionPacket(NBTTagCompound packetData) + { + if (packetData.hasKey("multiblockData")) + { + NBTTagCompound tag = packetData.getCompoundTag("multiblockData"); + if (isConnected()) { + this.controller.decodeDescriptionPacket(tag); + } else { + this.cachedMultiblockData = tag; + } + } + } +} diff --git a/src/Java/miscutil/core/multiblock/base/BaseMultiblockTE.java b/src/Java/miscutil/core/multiblock/base/BaseMultiblockTE.java new file mode 100644 index 0000000000..e91ebd6143 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/BaseMultiblockTE.java @@ -0,0 +1,100 @@ +package miscutil.core.multiblock.base; + +import miscutil.core.interfaces.IGuiManager; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockController; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockLogic; +import miscutil.core.xmod.forestry.core.interfaces.IFilterSlotDelegate; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.util.ChunkCoordinates; +import raisintoast.core.multiblock.IMultiblockPart; + +public abstract class BaseMultiblockTE<T extends IBaseMultiblockLogic> extends IMultiblockPart implements IFilterSlotDelegate, IGuiManager +{ + private final T multiblockLogic; + + public BaseMultiblockTE(T multiblockLogic) + { + this.multiblockLogic = multiblockLogic; + } + + @Override + public ChunkCoordinates getCoordinates() + { + return new ChunkCoordinates(this.xCoord, this.yCoord, this.zCoord); + } + + public T getMultiblockLogic() + { + return this.multiblockLogic; + } + + public abstract void onMachineAssembled(IBaseMultiblockController paramIMultiblockController, ChunkCoordinates paramChunkCoordinates1, ChunkCoordinates paramChunkCoordinates2); + + @Override + public abstract void onMachineBroken(); + + @Override + public void readFromNBT(NBTTagCompound data) + { + super.readFromNBT(data); + this.multiblockLogic.readFromNBT(data); + } + + @Override + public void writeToNBT(NBTTagCompound data) + { + super.writeToNBT(data); + this.multiblockLogic.writeToNBT(data); + } + + @Override + public boolean canUpdate() + { + return false; + } + + @Override + public final void invalidate() + { + super.invalidate(); + this.multiblockLogic.invalidate(this.worldObj, this); + } + + @Override + public final void onChunkUnload() + { + super.onChunkUnload(); + this.multiblockLogic.onChunkUnload(this.worldObj, this); + } + + @Override + public final void validate() + { + super.validate(); + this.multiblockLogic.validate(this.worldObj, this); + } + + @Override + public final Packet getDescriptionPacket() + { + NBTTagCompound packetData = new NBTTagCompound(); + this.multiblockLogic.encodeDescriptionPacket(packetData); + encodeDescriptionPacket(packetData); + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, packetData); + } + + @Override + public final void onDataPacket(NetworkManager network, S35PacketUpdateTileEntity packet) + { + NBTTagCompound nbtData = packet.func_148857_g(); + this.multiblockLogic.decodeDescriptionPacket(nbtData); + decodeDescriptionPacket(nbtData); + } + + protected void encodeDescriptionPacket(NBTTagCompound packetData) {} + + protected void decodeDescriptionPacket(NBTTagCompound packetData) {} +} diff --git a/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockComponent.java b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockComponent.java new file mode 100644 index 0000000000..c78012662e --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockComponent.java @@ -0,0 +1,17 @@ +package miscutil.core.multiblock.base.interfaces; + +import net.minecraft.util.ChunkCoordinates; + +import com.mojang.authlib.GameProfile; + +public interface IBaseMultiblockComponent { + public abstract ChunkCoordinates getCoordinates(); + + public abstract GameProfile getOwner(); + + public abstract IBaseMultiblockLogic getMultiblockLogic(); + + public abstract void onMachineAssembled(IBaseMultiblockController paramIMultiblockController, ChunkCoordinates paramChunkCoordinates1, ChunkCoordinates paramChunkCoordinates2); + + public abstract void onMachineBroken(); + } diff --git a/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockController.java b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockController.java new file mode 100644 index 0000000000..cd52328b03 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockController.java @@ -0,0 +1,18 @@ +package miscutil.core.multiblock.base.interfaces; + +import java.util.Collection; + +import javax.annotation.Nonnull; + +import raisintoast.core.multiblock.IMultiblockPart; + +public interface IBaseMultiblockController { + public abstract boolean isAssembled(); + + public abstract void reassemble(); + + public abstract String getLastValidationError(); + + @Nonnull + public abstract Collection<IMultiblockPart> getComponents(); + }
\ No newline at end of file diff --git a/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockControllerInternal.java b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockControllerInternal.java new file mode 100644 index 0000000000..9ebc9e8127 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockControllerInternal.java @@ -0,0 +1,52 @@ +package miscutil.core.multiblock.base.interfaces; + +import java.util.Set; + +import javax.annotation.Nonnull; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import raisintoast.core.common.CoordTriplet; +import raisintoast.core.multiblock.IMultiblockPart; + +public abstract interface IBaseMultiblockControllerInternal +extends IBaseMultiblockController { + +public abstract void attachBlock(IMultiblockPart paramIMultiblockComponent); + +public abstract void detachBlock(IMultiblockPart paramIMultiblockComponent, boolean paramBoolean); + +public abstract void checkIfMachineIsWhole(); + +public abstract void assimilate(IBaseMultiblockController paramIMultiblockControllerInternal); + +public abstract void _onAssimilated(IBaseMultiblockController paramIMultiblockControllerInternal); + +public abstract void onAssimilated(IBaseMultiblockController paramIMultiblockControllerInternal); + +public abstract void updateMultiblockEntity(); + +public abstract CoordTriplet getReferenceCoord(); + +public abstract void recalculateMinMaxCoords(); + +public abstract void formatDescriptionPacket(NBTTagCompound paramNBTTagCompound); + +public abstract void decodeDescriptionPacket(NBTTagCompound paramNBTTagCompound); + +public abstract World getWorld(); + +public abstract boolean isEmpty(); + +public abstract boolean shouldConsume(IBaseMultiblockController paramIMultiblockControllerInternal); + +public abstract String getPartsListString(); + +public abstract void auditParts(); + +@Nonnull +public abstract Set<IMultiblockPart> checkForDisconnections(); + +@Nonnull +public abstract Set<IMultiblockPart> detachAllBlocks(); +} diff --git a/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockLogic.java b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockLogic.java new file mode 100644 index 0000000000..4bc7e5b56f --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockLogic.java @@ -0,0 +1,27 @@ +package miscutil.core.multiblock.base.interfaces; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import raisintoast.core.multiblock.IMultiblockPart; + +public interface IBaseMultiblockLogic { + + public abstract boolean isConnected(); + + public abstract IBaseMultiblockController getController(); + + public abstract void validate(World paramWorld, IMultiblockPart paramIMultiblockComponent); + + public abstract void invalidate(World paramWorld, IMultiblockPart paramIMultiblockComponent); + + public abstract void onChunkUnload(World paramWorld, IMultiblockPart paramIMultiblockComponent); + + public abstract void encodeDescriptionPacket(NBTTagCompound paramNBTTagCompound); + + public abstract void decodeDescriptionPacket(NBTTagCompound paramNBTTagCompound); + + public abstract void readFromNBT(NBTTagCompound paramNBTTagCompound); + + public abstract void writeToNBT(NBTTagCompound paramNBTTagCompound); + +} diff --git a/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockSizeLimits.java b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockSizeLimits.java new file mode 100644 index 0000000000..ca266c2cc9 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/base/interfaces/IBaseMultiblockSizeLimits.java @@ -0,0 +1,19 @@ +package miscutil.core.multiblock.base.interfaces; + +public abstract interface IBaseMultiblockSizeLimits { + + public abstract int getMinNumberOfBlocksForAssembledMachine(); + + public abstract int getMaxXSize(); + + public abstract int getMaxZSize(); + + public abstract int getMaxYSize(); + + public abstract int getMinXSize(); + + public abstract int getMinYSize(); + + public abstract int getMinZSize(); + + }
\ No newline at end of file diff --git a/src/Java/miscutil/core/multiblock/test/TileAlveary.java b/src/Java/miscutil/core/multiblock/test/TileAlveary.java new file mode 100644 index 0000000000..7a39809508 --- /dev/null +++ b/src/Java/miscutil/core/multiblock/test/TileAlveary.java @@ -0,0 +1,66 @@ +package miscutil.core.multiblock.test; + +import miscutil.core.multiblock.abstracts.AbstractMultiblockLogic; +import miscutil.core.multiblock.abstracts.AbstractMultiblockTE; +import miscutil.core.multiblock.base.interfaces.IBaseMultiblockController; +import net.minecraft.util.ChunkCoordinates; +import forestry.api.apiculture.IAlvearyComponent; +import forestry.api.apiculture.IBeeHousing; +import forestry.core.gui.IHintSource; +import forestry.core.network.IStreamableGui; +import forestry.core.tiles.IClimatised; +import forestry.core.tiles.IRestrictedAccessTile; +import forestry.core.tiles.ITitled; + +public abstract class TileAlveary + extends AbstractMultiblockTE<AbstractMultiblockLogic> + implements IBeeHousing, IAlvearyComponent, IRestrictedAccessTile, IStreamableGui, ITitled, IClimatised, IHintSource +{ + + public static enum Type + { + PLAIN, ENTRANCE, SWARMER, FAN, HEATER, HYGRO, STABILIZER, SIEVE; + + public static final Type[] VALUES = values(); + + private Type() {} + } + + private final String unlocalizedTitle; + protected TileAlveary() + { + this(Type.PLAIN); + } + + protected TileAlveary(Type type) + { + super(new AbstractMultiblockLogic()); + this.unlocalizedTitle = ("tile.for.alveary." + type.ordinal() + ".name"); + } + + public int getIcon(int side) + { + return 0; + } + + @Override +public void onMachineAssembled(IBaseMultiblockController multiblockController, ChunkCoordinates minCoord, ChunkCoordinates maxCoord) + { + if (this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, getBlockType()); + markDirty(); + } + + @Override +public void onMachineBroken() + { + if (this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, getBlockType()); + markDirty(); + } + +} |