diff options
Diffstat (limited to 'src/Java/miscutil/core')
28 files changed, 1515 insertions, 63 deletions
diff --git a/src/Java/miscutil/core/gui/ModGUI.java b/src/Java/miscutil/core/gui/ModGUI.java deleted file mode 100644 index 82f6ebf3bf..0000000000 --- a/src/Java/miscutil/core/gui/ModGUI.java +++ /dev/null @@ -1,53 +0,0 @@ -package miscutil.core.gui; - -import miscutil.MiscUtils; -import miscutil.core.block.machine.heliumgen.container.ContainerHeliumGenerator; -import miscutil.core.block.machine.heliumgen.gui.GUIHeliumGenerator; -import miscutil.core.block.machine.heliumgen.tileentity.TileEntityHeliumGenerator; -import miscutil.core.handler.GuiHandler; -import miscutil.core.util.Utils; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.world.World; -import cpw.mods.fml.common.network.IGuiHandler; -import cpw.mods.fml.common.network.NetworkRegistry; - -public class ModGUI { - - - public static void init(){ - - Utils.LOG_INFO("Registering GUIs."); - NetworkRegistry.INSTANCE.registerGuiHandler(MiscUtils.instance, new GuiHandler()); - //Register GuiHandler - //NetworkRegistry.INSTANCE.registerGuiHandler(MiscUtils.instance, new GuiHandler()); - } -} - -class GUI_HANDLER implements IGuiHandler { - - @Override - public Object getClientGuiElement (int ID, EntityPlayer player, World world, int x, int y, int z){ - if(ID == 0) - return false; - else if(ID == 1) - return false; - else if(ID == 2) - return new GUIHeliumGenerator(player.inventory, (TileEntityHeliumGenerator)world.getTileEntity(x, y, z)); - else if(ID == 3) - return false; - return null; - } - - @Override - public Object getServerGuiElement (int ID, EntityPlayer player, World world, int x, int y, int z){ - if(ID == 0) - return false; - else if(ID == 1) - return false; - else if(ID == 2) - return new ContainerHeliumGenerator(player.inventory, (TileEntityHeliumGenerator)world.getTileEntity(x, y, z)); - else if(ID == 3) - return false; - return null; - } -} diff --git a/src/Java/miscutil/core/gui/beta/Gui_ID_Registry.java b/src/Java/miscutil/core/gui/beta/Gui_ID_Registry.java new file mode 100644 index 0000000000..11c97e8f9a --- /dev/null +++ b/src/Java/miscutil/core/gui/beta/Gui_ID_Registry.java @@ -0,0 +1,56 @@ +package miscutil.core.gui.beta; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import miscutil.core.interfaces.IGuiManagerMiscUtils; + +public class Gui_ID_Registry +{ + private static final Map<Class<? extends IGuiManagerMiscUtils>, MU_GuiId> classMap = new HashMap(); + private static final Map<Integer, MU_GuiId> idMap = new HashMap(); + private static int nextId = 0; + + static + { + //registerGuiHandlers(Gui_Types.Tile, Arrays.asList(new Class[] {TileAlveary.class})); + //registerGuiHandlers(MU_GuiType.Item, Arrays.asList(new Class[] { ItemBackpack.class, ItemBackpackNaturalist.class, ItemBeealyzer.class, ItemCatalogue.class, ItemFlutterlyzer.class, ItemHabitatLocator.class, ItemImprinter.class, ItemInfuser.class, ItemLetter.class, ItemSolderingIron.class, ItemTreealyzer.class })); + //registerGuiHandlers(MU_GuiType.Entity, Arrays.asList(new Class[] { EntityMinecartApiary.class, EntityMinecartBeehouse.class })); + } + + private static void registerGuiHandlers(Gui_Types MU_GuiType, List<Class<? extends IGuiManagerMiscUtils>> guiHandlerClasses) + { + for (Class<? extends IGuiManagerMiscUtils> tileGuiHandlerClass : guiHandlerClasses) + { + MU_GuiId guiId = new MU_GuiId(nextId++, MU_GuiType, tileGuiHandlerClass); + classMap.put(tileGuiHandlerClass, guiId); + idMap.put(Integer.valueOf(guiId.getId()), guiId); + } + } + + public static MU_GuiId getGuiIdForGuiHandler(IGuiManagerMiscUtils guiHandler) + { + Class<? extends IGuiManagerMiscUtils> guiHandlerClass = guiHandler.getClass(); + MU_GuiId guiId = (MU_GuiId)classMap.get(guiHandlerClass); + if (guiId == null) { + for (Map.Entry<Class<? extends IGuiManagerMiscUtils>, MU_GuiId> classGuiIdEntry : classMap.entrySet()) { + if (((Class)classGuiIdEntry.getKey()).isAssignableFrom(guiHandlerClass)) + { + guiId = (MU_GuiId)classGuiIdEntry.getValue(); + break; + } + } + } + if (guiId == null) { + throw new IllegalStateException("No gui ID for gui handler: " + guiHandler); + } + return guiId; + } + + public static MU_GuiId getGuiId(int id) + { + return (MU_GuiId)idMap.get(Integer.valueOf(id)); + } + +} diff --git a/src/Java/miscutil/core/gui/beta/Gui_Types.java b/src/Java/miscutil/core/gui/beta/Gui_Types.java new file mode 100644 index 0000000000..79e5a21dbd --- /dev/null +++ b/src/Java/miscutil/core/gui/beta/Gui_Types.java @@ -0,0 +1,8 @@ +package miscutil.core.gui.beta; + +public enum Gui_Types + { + Item, Tile, Entity; + + private Gui_Types() {} + }
\ No newline at end of file diff --git a/src/Java/miscutil/core/gui/beta/MU_GuiId.java b/src/Java/miscutil/core/gui/beta/MU_GuiId.java new file mode 100644 index 0000000000..2c97e62039 --- /dev/null +++ b/src/Java/miscutil/core/gui/beta/MU_GuiId.java @@ -0,0 +1,32 @@ +package miscutil.core.gui.beta; +import miscutil.core.interfaces.IGuiManagerMiscUtils; + +public class MU_GuiId + { + private final int id; + private final Gui_Types MU_GuiType; + private final Class<? extends IGuiManagerMiscUtils> guiHandlerClass; + + MU_GuiId(int id, Gui_Types MU_GuiType, Class<? extends IGuiManagerMiscUtils> guiHandlerClass) + { + this.id = id; + this.MU_GuiType = MU_GuiType; + this.guiHandlerClass = guiHandlerClass; + } + + public Gui_Types getGuiType() + { + return this.MU_GuiType; + } + + public Class<? extends IGuiManagerMiscUtils> getGuiHandlerClass() + { + return this.guiHandlerClass; + } + + public int getId() + { + return this.id; + } + } + diff --git a/src/Java/miscutil/core/handler/GuiHandler.java b/src/Java/miscutil/core/handler/GuiHandler.java index d604f1b147..92cb2a2812 100644 --- a/src/Java/miscutil/core/handler/GuiHandler.java +++ b/src/Java/miscutil/core/handler/GuiHandler.java @@ -1,14 +1,19 @@ package miscutil.core.handler; +import miscutil.MiscUtils; import miscutil.core.container.Container_Charger; import miscutil.core.container.Container_NHG; +import miscutil.core.gui.beta.Gui_ID_Registry; +import miscutil.core.gui.beta.MU_GuiId; import miscutil.core.gui.machine.GUI_Charger; import miscutil.core.gui.machine.GUI_NHG; +import miscutil.core.interfaces.IGuiManager; import miscutil.core.tileentities.machines.TileEntityCharger; import miscutil.core.tileentities.machines.TileEntityNHG; import miscutil.core.util.Utils; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChunkCoordinates; import net.minecraft.world.World; import cpw.mods.fml.common.network.IGuiHandler; @@ -17,8 +22,6 @@ public class GuiHandler implements IGuiHandler { private static final int GUI1 = 0; //Nuclear Helium Gen. private static final int GUI2 = 1; //Energy Charger - - @Override //ContainerModTileEntity public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { TileEntity te = world.getTileEntity(x, y, z); @@ -42,16 +45,48 @@ public class GuiHandler implements IGuiHandler { Utils.LOG_WARNING("getClientGuiElement Called by: "+player+", in world: "+player.dimension+" at x:"+x+", y:"+y+", z:"+z+"."); TileEntity te = world.getTileEntity(x, y, z); if (te != null){ - if (ID == GUI1){ - Utils.LOG_WARNING("Opening Gui with Id: "+ID+" NHG"); - return new GUI_NHG((TileEntityNHG) te, player); - } - else if (ID == GUI2){ - Utils.LOG_WARNING("Opening Gui with Id: "+ID+" Charger"); - return new GUI_Charger((TileEntityCharger) te, player); - } + if (ID == GUI1){ + Utils.LOG_WARNING("Opening Gui with Id: "+ID+" NHG"); + return new GUI_NHG((TileEntityNHG) te, player); + } + else if (ID == GUI2){ + Utils.LOG_WARNING("Opening Gui with Id: "+ID+" Charger"); + return new GUI_Charger((TileEntityCharger) te, player); + } } return null; } + + + + //New Methods + public static void openGui(EntityPlayer entityplayer, IGuiManager guiHandler) + { + openGui(entityplayer, guiHandler, (short)0); + } + + public static void openGui(EntityPlayer entityplayer, IGuiManager guiHandler, short data) + { + int guiData = encodeGuiData(guiHandler, data); + ChunkCoordinates coordinates = guiHandler.getCoordinates(); + entityplayer.openGui(MiscUtils.instance, guiData, entityplayer.worldObj, coordinates.posX, coordinates.posY, coordinates.posZ); + } + + private static int encodeGuiData(IGuiManager guiHandler, short data) + { + MU_GuiId guiId = Gui_ID_Registry.getGuiIdForGuiHandler(guiHandler); + return data << 16 | guiId.getId(); + } + + private static MU_GuiId decodeGuiID(int guiData) + { + int guiId = guiData & 0xFF; + return Gui_ID_Registry.getGuiId(guiId); + } + + private static short decodeGuiData(int guiId) + { + return (short)(guiId >> 16); + } }
\ No newline at end of file diff --git a/src/Java/miscutil/core/interfaces/IGuiManager.java b/src/Java/miscutil/core/interfaces/IGuiManager.java new file mode 100644 index 0000000000..bca5b90ecf --- /dev/null +++ b/src/Java/miscutil/core/interfaces/IGuiManager.java @@ -0,0 +1,16 @@ +package miscutil.core.interfaces; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; + +public abstract interface IGuiManager extends IGuiManagerMiscUtils{ + + public abstract ChunkCoordinates getCoordinates(); + + public abstract World getWorld(); + + public abstract Object getGui(EntityPlayer paramEntityPlayer, int paramInt); + + public abstract Object getContainer(EntityPlayer paramEntityPlayer, int paramInt); +} diff --git a/src/Java/miscutil/core/interfaces/IGuiManagerMiscUtils.java b/src/Java/miscutil/core/interfaces/IGuiManagerMiscUtils.java new file mode 100644 index 0000000000..1a5ab4a3a6 --- /dev/null +++ b/src/Java/miscutil/core/interfaces/IGuiManagerMiscUtils.java @@ -0,0 +1,3 @@ +package miscutil.core.interfaces; + +public abstract interface IGuiManagerMiscUtils {}
\ No newline at end of file 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(); + } + +} diff --git a/src/Java/miscutil/core/xmod/forestry/core/interfaces/IFilterSlotDelegate.java b/src/Java/miscutil/core/xmod/forestry/core/interfaces/IFilterSlotDelegate.java new file mode 100644 index 0000000000..d3290d7491 --- /dev/null +++ b/src/Java/miscutil/core/xmod/forestry/core/interfaces/IFilterSlotDelegate.java @@ -0,0 +1,10 @@ +package miscutil.core.xmod.forestry.core.interfaces; + +import net.minecraft.item.ItemStack; + +public abstract interface IFilterSlotDelegate +{ + public abstract boolean canSlotAccept(int paramInt, ItemStack paramItemStack); + + public abstract boolean isLocked(int paramInt); +} diff --git a/src/Java/miscutil/core/xmod/forestry/core/interfaces/IInventoryAdapter.java b/src/Java/miscutil/core/xmod/forestry/core/interfaces/IInventoryAdapter.java new file mode 100644 index 0000000000..95a24d90e3 --- /dev/null +++ b/src/Java/miscutil/core/xmod/forestry/core/interfaces/IInventoryAdapter.java @@ -0,0 +1,7 @@ +package miscutil.core.xmod.forestry.core.interfaces; + +import net.minecraft.inventory.ISidedInventory; + +public abstract interface IInventoryAdapter + extends ISidedInventory, IFilterSlotDelegate, INBTTagable +{}
\ No newline at end of file diff --git a/src/Java/miscutil/core/xmod/forestry/core/interfaces/INBTTagable.java b/src/Java/miscutil/core/xmod/forestry/core/interfaces/INBTTagable.java new file mode 100644 index 0000000000..6053e5f5ba --- /dev/null +++ b/src/Java/miscutil/core/xmod/forestry/core/interfaces/INBTTagable.java @@ -0,0 +1,10 @@ +package miscutil.core.xmod.forestry.core.interfaces; + +import net.minecraft.nbt.NBTTagCompound; + +public abstract interface INBTTagable +{ + public abstract void readFromNBT(NBTTagCompound paramNBTTagCompound); + + public abstract void writeToNBT(NBTTagCompound paramNBTTagCompound); +} diff --git a/src/Java/miscutil/core/xmod/forestry/core/inventory/FakeInventoryAdapter.java b/src/Java/miscutil/core/xmod/forestry/core/inventory/FakeInventoryAdapter.java new file mode 100644 index 0000000000..39d1075dc7 --- /dev/null +++ b/src/Java/miscutil/core/xmod/forestry/core/inventory/FakeInventoryAdapter.java @@ -0,0 +1,120 @@ +package miscutil.core.xmod.forestry.core.inventory; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import forestry.core.inventory.IInventoryAdapter; + +public class FakeInventoryAdapter implements IInventoryAdapter { + + public static final int[] SLOTS_NONE = new int[0]; + private static FakeInventoryAdapter instance; + public static FakeInventoryAdapter instance(){ + if (instance == null) { + instance = new FakeInventoryAdapter(); + } + return instance; + } + + @Override + public boolean canSlotAccept(int slotIndex, ItemStack itemStack){ + return false; + } + + @Override + public boolean isLocked(int slotIndex) + { + return false; + } + + @Override + public int[] getAccessibleSlotsFromSide(int p_94128_1_) + { + return SLOTS_NONE; + } + + @Override + public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_) + { + return false; + } + + @Override + public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_) + { + return false; + } + + @Override + public int getSizeInventory() + { + return 0; + } + + @Override + public ItemStack getStackInSlot(int p_70301_1_) + { + return null; + } + + @Override + public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) + { + return null; + } + + @Override + public ItemStack getStackInSlotOnClosing(int p_70304_1_) + { + return null; + } + + @Override + public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {} + + @Override + public String getInventoryName() + { + return null; + } + + @Override + public boolean hasCustomInventoryName() + { + return false; + } + + @Override + public int getInventoryStackLimit() + { + return 0; + } + + @Override + public void markDirty() {} + + @Override + public boolean isUseableByPlayer(EntityPlayer p_70300_1_) + { + return false; + } + + @Override + public void openInventory() {} + + @Override + public void closeInventory() {} + + @Override + public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) + { + return false; + } + + @Override + public void readFromNBT(NBTTagCompound nbttagcompound) {} + + @Override + public void writeToNBT(NBTTagCompound nbttagcompound) {} + +} |