Import new GUI sync framework and make sure the code can use it

src/main/java/refinedstorage/container/ContainerBase.java

@@ -10,12 +10,15 @@ import refinedstorage.api.storage.CompareUtils;
 import refinedstorage.container.slot.SlotDisabled;
 import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.container.slot.SlotSpecimenLegacy;
+import refinedstorage.tile.TileBase;
 import refinedstorage.tile.grid.WirelessGrid;
 
 public abstract class ContainerBase extends Container {
+    private TileBase tile;
     private EntityPlayer player;
 
-    public ContainerBase(EntityPlayer player) {
+    public ContainerBase(TileBase tile, EntityPlayer player) {
+        this.tile = tile;
         this.player = player;
     }
 
@@ -23,6 +26,10 @@ public abstract class ContainerBase extends Container {
         return player;
     }
 
+    public TileBase getTile() {
+        return tile;
+    }
+
     protected void addPlayerInventory(int xInventory, int yInventory) {
         int id = 0;
 

src/main/java/refinedstorage/container/ContainerConstructor.java

@@ -8,8 +8,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileConstructor;
 
 public class ContainerConstructor extends ContainerBase {
-    public ContainerConstructor(EntityPlayer player, TileConstructor constructor) {
-        super(player);
+    public ContainerConstructor(TileConstructor constructor, EntityPlayer player) {
+        super(constructor, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(constructor.getUpgrades(), i, 187, 6 + (i * 18)));

src/main/java/refinedstorage/container/ContainerController.java

@@ -1,10 +1,11 @@
 package refinedstorage.container;
 
 import net.minecraft.entity.player.EntityPlayer;
+import refinedstorage.tile.TileController;
 
 public class ContainerController extends ContainerBase {
-    public ContainerController(EntityPlayer player) {
-        super(player);
+    public ContainerController(TileController controller, EntityPlayer player) {
+        super(controller, player);
 
         addPlayerInventory(8, 99);
     }

src/main/java/refinedstorage/container/ContainerCrafter.java

@@ -7,8 +7,8 @@ import net.minecraftforge.items.SlotItemHandler;
 import refinedstorage.tile.TileCrafter;
 
 public class ContainerCrafter extends ContainerStorage {
-    public ContainerCrafter(EntityPlayer player, TileCrafter crafter) {
-        super(player);
+    public ContainerCrafter(TileCrafter crafter, EntityPlayer player) {
+        super(crafter, player);
 
         for (int i = 0; i < 9; ++i) {
             addSlotToContainer(new SlotItemHandler(crafter.getPatterns(), i, 8 + (18 * i), 20));

src/main/java/refinedstorage/container/ContainerCraftingMonitor.java

@@ -1,10 +1,11 @@
 package refinedstorage.container;
 
 import net.minecraft.entity.player.EntityPlayer;
+import refinedstorage.tile.TileCraftingMonitor;
 
 public class ContainerCraftingMonitor extends ContainerBase {
-    public ContainerCraftingMonitor(EntityPlayer player) {
-        super(player);
+    public ContainerCraftingMonitor(TileCraftingMonitor craftingMonitor, EntityPlayer player) {
+        super(craftingMonitor, player);
 
         addPlayerInventory(8, 148);
     }

src/main/java/refinedstorage/container/ContainerCraftingSettings.java

@@ -11,7 +11,7 @@ import javax.annotation.Nullable;
 
 public class ContainerCraftingSettings extends ContainerBase {
     public ContainerCraftingSettings(EntityPlayer player, final ItemStack stack) {
-        super(player);
+        super(null, player);
 
         final ItemStack slot = ItemHandlerHelper.copyStackWithSize(stack, 1);
 

src/main/java/refinedstorage/container/ContainerDestructor.java

@@ -8,8 +8,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileDestructor;
 
 public class ContainerDestructor extends ContainerBase {
-    public ContainerDestructor(EntityPlayer player, TileDestructor destructor) {
-        super(player);
+    public ContainerDestructor(TileDestructor destructor, EntityPlayer player) {
+        super(destructor, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(destructor.getUpgrades(), i, 187, 6 + (i * 18)));

src/main/java/refinedstorage/container/ContainerDetector.java

@@ -7,8 +7,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileDetector;
 
 public class ContainerDetector extends ContainerBase {
-    public ContainerDetector(EntityPlayer player, TileDetector detector) {
-        super(player);
+    public ContainerDetector(TileDetector detector, EntityPlayer player) {
+        super(detector, player);
 
         addSlotToContainer(new SlotSpecimen(detector.getInventory(), 0, 107, 20));
 

src/main/java/refinedstorage/container/ContainerDiskDrive.java

@@ -7,8 +7,8 @@ import net.minecraftforge.items.SlotItemHandler;
 import refinedstorage.tile.TileDiskDrive;
 
 public class ContainerDiskDrive extends ContainerStorage {
-    public ContainerDiskDrive(EntityPlayer player, TileDiskDrive drive) {
-        super(player);
+    public ContainerDiskDrive(TileDiskDrive drive, EntityPlayer player) {
+        super(drive, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(drive.getDisks(), i, 98 + (i * 18), 78));

src/main/java/refinedstorage/container/ContainerExporter.java

@@ -8,8 +8,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileExporter;
 
 public class ContainerExporter extends ContainerBase {
-    public ContainerExporter(EntityPlayer player, TileExporter exporter) {
-        super(player);
+    public ContainerExporter(TileExporter exporter, EntityPlayer player) {
+        super(exporter, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(exporter.getUpgrades(), i, 187, 6 + (i * 18)));

src/main/java/refinedstorage/container/ContainerGrid.java

@@ -6,6 +6,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraftforge.items.SlotItemHandler;
 import refinedstorage.block.EnumGridType;
 import refinedstorage.container.slot.*;
+import refinedstorage.tile.TileBase;
 import refinedstorage.tile.grid.IGrid;
 import refinedstorage.tile.grid.TileGrid;
 import refinedstorage.tile.grid.WirelessGrid;
@@ -16,8 +17,8 @@ public class ContainerGrid extends ContainerBase {
     private SlotGridCraftingResult craftingResultSlot;
     private SlotDisabled patternResultSlot;
 
-    public ContainerGrid(EntityPlayer player, IGrid grid) {
-        super(player);
+    public ContainerGrid(IGrid grid, EntityPlayer player) {
+        super(grid instanceof TileBase ? (TileBase) grid : null, player);
 
         this.grid = grid;
 

src/main/java/refinedstorage/container/ContainerGridFilter.java

@@ -11,7 +11,7 @@ public class ContainerGridFilter extends ContainerBase {
     private ItemStack stack;
 
     public ContainerGridFilter(EntityPlayer player, ItemStack stack) {
-        super(player);
+        super(null, player);
 
         this.stack = stack;
         this.filter = new ItemHandlerGridFilter(stack);

src/main/java/refinedstorage/container/ContainerImporter.java

@@ -8,8 +8,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileImporter;
 
 public class ContainerImporter extends ContainerBase {
-    public ContainerImporter(EntityPlayer player, TileImporter importer) {
-        super(player);
+    public ContainerImporter(TileImporter importer, EntityPlayer player) {
+        super(importer, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(importer.getUpgrades(), i, 187, 6 + (i * 18)));

src/main/java/refinedstorage/container/ContainerInterface.java

@@ -9,8 +9,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileInterface;
 
 public class ContainerInterface extends ContainerBase {
-    public ContainerInterface(EntityPlayer player, TileInterface tile) {
-        super(player);
+    public ContainerInterface(TileInterface tile, EntityPlayer player) {
+        super(tile, player);
 
         for (int i = 0; i < 9; ++i) {
             addSlotToContainer(new SlotItemHandler(tile.getImportItems(), i, 8 + (18 * i), 20));

src/main/java/refinedstorage/container/ContainerNetworkTransmitter.java

@@ -7,10 +7,11 @@ import net.minecraftforge.items.SlotItemHandler;
 import refinedstorage.tile.TileNetworkTransmitter;
 
 public class ContainerNetworkTransmitter extends ContainerBase {
-    public ContainerNetworkTransmitter(EntityPlayer player, TileNetworkTransmitter networkTransmitter) {
-        super(player);
+    public ContainerNetworkTransmitter(TileNetworkTransmitter networkTransmitter, EntityPlayer player) {
+        super(networkTransmitter, player);
 
         addSlotToContainer(new SlotItemHandler(networkTransmitter.getNetworkCard(), 0, 8, 20));
+
         addSlotToContainer(new SlotItemHandler(networkTransmitter.getUpgrades(), 0, 187, 6));
 
         addPlayerInventory(8, 55);

src/main/java/refinedstorage/container/ContainerProcessingPatternEncoder.java

@@ -9,8 +9,8 @@ import refinedstorage.container.slot.SlotSpecimen;
 import refinedstorage.tile.TileProcessingPatternEncoder;
 
 public class ContainerProcessingPatternEncoder extends ContainerBase {
-    public ContainerProcessingPatternEncoder(EntityPlayer player, TileProcessingPatternEncoder processingPatternEncoder) {
-        super(player);
+    public ContainerProcessingPatternEncoder(TileProcessingPatternEncoder processingPatternEncoder, EntityPlayer player) {
+        super(processingPatternEncoder, player);
 
         addSlotToContainer(new SlotItemHandler(processingPatternEncoder.getPatterns(), 0, 152, 18));
         addSlotToContainer(new SlotOutput(processingPatternEncoder.getPatterns(), 1, 152, 58));

src/main/java/refinedstorage/container/ContainerRelay.java

@@ -1,10 +1,11 @@
 package refinedstorage.container;
 
 import net.minecraft.entity.player.EntityPlayer;
+import refinedstorage.tile.TileRelay;
 
 public class ContainerRelay extends ContainerBase {
-    public ContainerRelay(EntityPlayer player) {
-        super(player);
+    public ContainerRelay(TileRelay relay, EntityPlayer player) {
+        super(relay, player);
 
         addPlayerInventory(8, 50);
     }

src/main/java/refinedstorage/container/ContainerSolderer.java

@@ -9,8 +9,8 @@ import refinedstorage.container.slot.SlotOutput;
 import refinedstorage.tile.TileSolderer;
 
 public class ContainerSolderer extends ContainerBase {
-    public ContainerSolderer(EntityPlayer player, TileSolderer solderer) {
-        super(player);
+    public ContainerSolderer(TileSolderer solderer, EntityPlayer player) {
+        super(solderer, player);
 
         int x = 44;
         int y = 20;

src/main/java/refinedstorage/container/ContainerStorage.java

@@ -3,14 +3,15 @@ package refinedstorage.container;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraftforge.items.IItemHandler;
 import refinedstorage.container.slot.SlotSpecimen;
+import refinedstorage.tile.TileBase;
 
 public class ContainerStorage extends ContainerBase {
-    public ContainerStorage(EntityPlayer player) {
-        super(player);
+    public ContainerStorage(TileBase tile, EntityPlayer player) {
+        super(tile, player);
     }
 
-    public ContainerStorage(EntityPlayer player, IItemHandler filters) {
-        this(player);
+    public ContainerStorage(TileBase tile, EntityPlayer player, IItemHandler filters) {
+        this(tile, player);
 
         addSpecimenAndPlayerInventorySlots(filters);
     }

src/main/java/refinedstorage/container/ContainerWirelessTransmitter.java

@@ -7,8 +7,8 @@ import net.minecraftforge.items.SlotItemHandler;
 import refinedstorage.tile.TileWirelessTransmitter;
 
 public class ContainerWirelessTransmitter extends ContainerBase {
-    public ContainerWirelessTransmitter(EntityPlayer player, TileWirelessTransmitter wirelessTransmitter) {
-        super(player);
+    public ContainerWirelessTransmitter(TileWirelessTransmitter wirelessTransmitter, EntityPlayer player) {
+        super(wirelessTransmitter, player);
 
         for (int i = 0; i < 4; ++i) {
             addSlotToContainer(new SlotItemHandler(wirelessTransmitter.getUpgrades(), i, 187, 6 + (i * 18)));

src/main/java/refinedstorage/gui/GuiHandler.java

@@ -18,39 +18,39 @@ public class GuiHandler implements IGuiHandler {
     private Container getContainer(int ID, EntityPlayer player, TileEntity tile) {
         switch (ID) {
             case RefinedStorageGui.CONTROLLER:
-                return new ContainerController(player);
+                return new ContainerController((TileController) tile, player);
             case RefinedStorageGui.GRID:
-                return new ContainerGrid(player, (TileGrid) tile);
+                return new ContainerGrid((TileGrid) tile, player);
             case RefinedStorageGui.DISK_DRIVE:
-                return new ContainerDiskDrive(player, (TileDiskDrive) tile);
+                return new ContainerDiskDrive((TileDiskDrive) tile, player);
             case RefinedStorageGui.IMPORTER:
-                return new ContainerImporter(player, (TileImporter) tile);
+                return new ContainerImporter((TileImporter) tile, player);
             case RefinedStorageGui.EXPORTER:
-                return new ContainerExporter(player, (TileExporter) tile);
+                return new ContainerExporter((TileExporter) tile, player);
             case RefinedStorageGui.DETECTOR:
-                return new ContainerDetector(player, (TileDetector) tile);
+                return new ContainerDetector((TileDetector) tile, player);
             case RefinedStorageGui.SOLDERER:
-                return new ContainerSolderer(player, (TileSolderer) tile);
+                return new ContainerSolderer((TileSolderer) tile, player);
             case RefinedStorageGui.DESTRUCTOR:
-                return new ContainerDestructor(player, (TileDestructor) tile);
+                return new ContainerDestructor((TileDestructor) tile, player);
             case RefinedStorageGui.CONSTRUCTOR:
-                return new ContainerConstructor(player, (TileConstructor) tile);
+                return new ContainerConstructor((TileConstructor) tile, player);
             case RefinedStorageGui.STORAGE:
-                return new ContainerStorage(player, ((IStorageGui) tile).getFilters());
+                return new ContainerStorage((TileBase) tile, player, ((IStorageGui) tile).getFilters());
             case RefinedStorageGui.RELAY:
-                return new ContainerRelay(player);
+                return new ContainerRelay((TileRelay) tile, player);
             case RefinedStorageGui.INTERFACE:
-                return new ContainerInterface(player, (TileInterface) tile);
+                return new ContainerInterface((TileInterface) tile, player);
             case RefinedStorageGui.CRAFTING_MONITOR:
-                return new ContainerCraftingMonitor(player);
+                return new ContainerCraftingMonitor((TileCraftingMonitor) tile, player);
             case RefinedStorageGui.WIRELESS_TRANSMITTER:
-                return new ContainerWirelessTransmitter(player, (TileWirelessTransmitter) tile);
+                return new ContainerWirelessTransmitter((TileWirelessTransmitter) tile, player);
             case RefinedStorageGui.CRAFTER:
-                return new ContainerCrafter(player, (TileCrafter) tile);
+                return new ContainerCrafter((TileCrafter) tile, player);
             case RefinedStorageGui.PROCESSING_PATTERN_ENCODER:
-                return new ContainerProcessingPatternEncoder(player, (TileProcessingPatternEncoder) tile);
+                return new ContainerProcessingPatternEncoder((TileProcessingPatternEncoder) tile, player);
             case RefinedStorageGui.NETWORK_TRANSMITTER:
-                return new ContainerNetworkTransmitter(player, (TileNetworkTransmitter) tile);
+                return new ContainerNetworkTransmitter((TileNetworkTransmitter) tile, player);
             default:
                 return null;
         }
@@ -61,7 +61,7 @@ public class GuiHandler implements IGuiHandler {
     }
 
     private ContainerGrid getWirelessGridContainer(EntityPlayer player, int hand) {
-        return new ContainerGrid(player, getWirelessGrid(player, hand));
+        return new ContainerGrid(getWirelessGrid(player, hand), player);
     }
 
     private ContainerGridFilter getGridFilterContainer(EntityPlayer player, int hand) {
@@ -128,8 +128,8 @@ public class GuiHandler implements IGuiHandler {
     }
 
     private GuiGrid getWirelessGridGui(EntityPlayer player, int hand) {
-        WirelessGrid wirelessGrid = getWirelessGrid(player, hand);
+        WirelessGrid grid = getWirelessGrid(player, hand);
 
-        return new GuiGrid(new ContainerGrid(player, wirelessGrid), wirelessGrid);
+        return new GuiGrid(new ContainerGrid(grid, player), grid);
     }
 }

src/main/java/refinedstorage/network/MessageTileDataParameter.java

@@ -0,0 +1,51 @@
+package refinedstorage.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import refinedstorage.tile.data.TileDataManager;
+import refinedstorage.tile.data.TileDataParameter;
+
+import java.io.IOException;
+
+public class MessageTileDataParameter implements IMessage, IMessageHandler<MessageTileDataParameter, IMessage> {
+    private TileEntity tile;
+    private TileDataParameter parameter;
+
+    public MessageTileDataParameter() {
+    }
+
+    public MessageTileDataParameter(TileEntity tile, TileDataParameter parameter) {
+        this.tile = tile;
+        this.parameter = parameter;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        int id = buf.readInt();
+
+        TileDataParameter parameter = TileDataManager.getParameter(id);
+
+        if (parameter != null) {
+            try {
+                parameter.setValue(parameter.getSerializer().read(new PacketBuffer(buf)));
+            } catch (IOException e) {
+            }
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(parameter.getId());
+
+        parameter.getSerializer().write((PacketBuffer) buf, parameter.getValueProducer().getValue(tile));
+    }
+
+    @Override
+    public IMessage onMessage(MessageTileDataParameter message, MessageContext ctx) {
+        return null;
+    }
+}

src/main/java/refinedstorage/network/MessageTileDataParameterUpdate.java

@@ -0,0 +1,60 @@
+package refinedstorage.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.Container;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import refinedstorage.container.ContainerBase;
+import refinedstorage.tile.data.ITileDataConsumer;
+import refinedstorage.tile.data.TileDataManager;
+import refinedstorage.tile.data.TileDataParameter;
+
+import java.io.IOException;
+
+public class MessageTileDataParameterUpdate extends MessageHandlerPlayerToServer<MessageTileDataParameterUpdate> implements IMessage {
+    private TileDataParameter parameter;
+    private Object value;
+
+    public MessageTileDataParameterUpdate() {
+    }
+
+    public MessageTileDataParameterUpdate(TileDataParameter parameter, Object value) {
+        this.parameter = parameter;
+        this.value = value;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        int id = buf.readInt();
+
+        parameter = TileDataManager.getParameter(id);
+
+        if (parameter != null) {
+            try {
+                value = parameter.getSerializer().read(new PacketBuffer(buf));
+            } catch (IOException e) {
+            }
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(parameter.getId());
+
+        parameter.getSerializer().write((PacketBuffer) buf, value);
+    }
+
+    @Override
+    public void handle(MessageTileDataParameterUpdate message, EntityPlayerMP player) {
+        Container c = player.openContainer;
+
+        if (c instanceof ContainerBase) {
+            ITileDataConsumer consumer = message.parameter.getValueConsumer();
+
+            if (consumer != null) {
+                consumer.setValue(((ContainerBase) c).getTile(), message.value);
+            }
+        }
+    }
+}

src/main/java/refinedstorage/proxy/CommonProxy.java

@@ -5,6 +5,7 @@ import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
@@ -27,6 +28,7 @@ import refinedstorage.gui.GuiHandler;
 import refinedstorage.item.*;
 import refinedstorage.network.*;
 import refinedstorage.tile.*;
+import refinedstorage.tile.data.ContainerListener;
 import refinedstorage.tile.externalstorage.TileExternalStorage;
 import refinedstorage.tile.grid.TileGrid;
 
@@ -38,6 +40,8 @@ public class CommonProxy {
 
         int id = 0;
 
+        RefinedStorage.INSTANCE.network.registerMessage(MessageTileDataParameter.class, MessageTileDataParameter.class, id++, Side.CLIENT);
+        RefinedStorage.INSTANCE.network.registerMessage(MessageTileDataParameterUpdate.class, MessageTileDataParameterUpdate.class, id++, Side.SERVER);
         RefinedStorage.INSTANCE.network.registerMessage(MessageTileContainerUpdate.class, MessageTileContainerUpdate.class, id++, Side.CLIENT);
         RefinedStorage.INSTANCE.network.registerMessage(MessageRedstoneModeUpdate.class, MessageRedstoneModeUpdate.class, id++, Side.SERVER);
         RefinedStorage.INSTANCE.network.registerMessage(MessageGridInsertHeld.class, MessageGridInsertHeld.class, id++, Side.SERVER);
@@ -61,6 +65,8 @@ public class CommonProxy {
 
         NetworkRegistry.INSTANCE.registerGuiHandler(RefinedStorage.INSTANCE, new GuiHandler());
 
+        MinecraftForge.EVENT_BUS.register(new ContainerListener());
+
         GameRegistry.registerTileEntity(TileController.class, ID + ":controller");
         GameRegistry.registerTileEntity(TileGrid.class, ID + ":grid");
         GameRegistry.registerTileEntity(TileDiskDrive.class, ID + ":disk_drive");

src/main/java/refinedstorage/tile/TileBase.java

@@ -22,6 +22,7 @@ import net.minecraftforge.items.wrapper.InvWrapper;
 import net.minecraftforge.items.wrapper.SidedInvWrapper;
 import refinedstorage.RefinedStorage;
 import refinedstorage.network.MessageTileContainerUpdate;
+import refinedstorage.tile.data.TileDataManager;
 
 import javax.annotation.Nullable;
 
@@ -33,6 +34,7 @@ public abstract class TileBase extends TileEntity implements ITickable {
 
     private EnumFacing direction = EnumFacing.NORTH;
 
+    protected TileDataManager dataManager = new TileDataManager(this);
     protected int ticks = 0;
 
     @Override
@@ -64,6 +66,10 @@ public abstract class TileBase extends TileEntity implements ITickable {
         return direction;
     }
 
+    public TileDataManager getDataManager() {
+        return dataManager;
+    }
+
     public NBTTagCompound write(NBTTagCompound tag) {
         tag.setInteger(NBT_DIRECTION, direction.ordinal());
 

src/main/java/refinedstorage/tile/data/ContainerListener.java

@@ -0,0 +1,23 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.Container;
+import net.minecraftforge.event.entity.player.PlayerContainerEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import refinedstorage.container.ContainerBase;
+import refinedstorage.tile.TileBase;
+
+public class ContainerListener {
+    @SubscribeEvent
+    public void onContainerOpen(PlayerContainerEvent.Open e) {
+        Container container = e.getContainer();
+
+        if (container instanceof ContainerBase) {
+            TileBase tile = ((ContainerBase) container).getTile();
+
+            if (tile != null && !tile.getWorld().isRemote) {
+                tile.getDataManager().sendParametersTo((EntityPlayerMP) e.getEntityPlayer());
+            }
+        }
+    }
+}

src/main/java/refinedstorage/tile/data/ITileDataConsumer.java

@@ -0,0 +1,7 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.tileentity.TileEntity;
+
+public interface ITileDataConsumer<T, E extends TileEntity> {
+    void setValue(E tile, T value);
+}

src/main/java/refinedstorage/tile/data/ITileDataProducer.java

@@ -0,0 +1,7 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.tileentity.TileEntity;
+
+public interface ITileDataProducer<T, E extends TileEntity> {
+    T getValue(E tile);
+}

src/main/java/refinedstorage/tile/data/TileDataManager.java

@@ -0,0 +1,98 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.Container;
+import net.minecraft.network.datasync.DataSerializer;
+import net.minecraft.tileentity.TileEntity;
+import refinedstorage.RefinedStorage;
+import refinedstorage.container.ContainerBase;
+import refinedstorage.network.MessageTileDataParameter;
+import refinedstorage.network.MessageTileDataParameterUpdate;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TileDataManager {
+    private static int PARAMETER_ID = 0;
+    private static Map<Integer, TileDataParameter> PARAMETER_MAP = new HashMap<Integer, TileDataParameter>();
+
+    private List<TileDataParameter> parameters = new ArrayList<TileDataParameter>();
+
+    private List<TileDataParameter> watchedParameters = new ArrayList<TileDataParameter>();
+    private List<Object> watchedParametersCache = new ArrayList<Object>();
+
+    public static TileDataParameter createParameter(DataSerializer serializer, ITileDataProducer producer) {
+        return createParameter(serializer, producer, null);
+    }
+
+    public static TileDataParameter createParameter(DataSerializer serializer, ITileDataProducer producer, ITileDataConsumer consumer) {
+        TileDataParameter parameter = new TileDataParameter(PARAMETER_ID++, serializer, producer, consumer);
+
+        PARAMETER_MAP.put(parameter.getId(), parameter);
+
+        return parameter;
+    }
+
+    public static TileDataParameter getParameter(int id) {
+        return PARAMETER_MAP.get(id);
+    }
+
+    public static <T> void setParameter(TileDataParameter<T> parameter, T value) {
+        RefinedStorage.INSTANCE.network.sendToServer(new MessageTileDataParameterUpdate(parameter, value));
+    }
+
+    private TileEntity tile;
+
+    public TileDataManager(TileEntity tile) {
+        this.tile = tile;
+    }
+
+    public void addParameter(TileDataParameter parameter) {
+        parameters.add(parameter);
+    }
+
+    public void addWatchedParameter(TileDataParameter parameter) {
+        addParameter(parameter);
+
+        watchedParameters.add(parameter);
+        watchedParametersCache.add(null);
+    }
+
+    public void detectAndSendChanges() {
+        for (int i = 0; i < watchedParameters.size(); ++i) {
+            TileDataParameter parameter = watchedParameters.get(i);
+
+            Object real = parameter.getValueProducer().getValue(tile);
+            Object cached = watchedParametersCache.get(i);
+
+            if (!real.equals(cached)) {
+                watchedParametersCache.set(i, real);
+
+                sendParameterToWatchers(parameter);
+            }
+        }
+    }
+
+    public void sendParametersTo(EntityPlayerMP player) {
+        for (TileDataParameter parameter : parameters) {
+            sendParameter(player, parameter);
+        }
+    }
+
+    public void sendParameter(EntityPlayerMP player, TileDataParameter parameter) {
+        RefinedStorage.INSTANCE.network.sendTo(new MessageTileDataParameter(tile, parameter), player);
+    }
+
+    public void sendParameterToWatchers(TileDataParameter parameter) {
+        for (EntityPlayer player : tile.getWorld().playerEntities) {
+            Container container = player.openContainer;
+
+            if (container instanceof ContainerBase && ((ContainerBase) container).getTile().getPos().equals(tile.getPos())) {
+                sendParameter((EntityPlayerMP) player, parameter);
+            }
+        }
+    }
+}

src/main/java/refinedstorage/tile/data/TileDataParameter.java

@@ -0,0 +1,42 @@
+package refinedstorage.tile.data;
+
+import net.minecraft.network.datasync.DataSerializer;
+
+public class TileDataParameter<T> {
+    private int id;
+    private DataSerializer<T> serializer;
+    private ITileDataProducer valueProducer;
+    private ITileDataConsumer valueConsumer;
+    private T value;
+
+    public TileDataParameter(int id, DataSerializer<T> serializer, ITileDataProducer producer, ITileDataConsumer consumer) {
+        this.id = id;
+        this.serializer = serializer;
+        this.valueProducer = producer;
+        this.valueConsumer = consumer;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public DataSerializer<T> getSerializer() {
+        return serializer;
+    }
+
+    public ITileDataProducer getValueProducer() {
+        return valueProducer;
+    }
+
+    public ITileDataConsumer getValueConsumer() {
+        return valueConsumer;
+    }
+
+    public void setValue(T value) {
+        this.value = value;
+    }
+
+    public T getValue() {
+        return value;
+    }
+}