add Programming Table

buildcraft_resources/assets/buildcraft/lang/en_US.lang

@@ -294,6 +294,7 @@ tile.markerBlock.name=Land Mark
 tile.miningWellBlock.name=Mining Well
 tile.pathMarkerBlock.name=Path Mark
 tile.plainPipeBlock.name=Mining Pipe
+tile.programmingTableBlock.name=Programming Table
 tile.pumpBlock.name=Pump
 tile.refineryBlock.name=Refinery
 tile.requester.name=Requester

common/buildcraft/BuildCraftCore.java

@@ -96,6 +96,7 @@ import buildcraft.core.network.PacketHandler;
 import buildcraft.core.proxy.CoreProxy;
 import buildcraft.core.recipes.AssemblyRecipeManager;
 import buildcraft.core.recipes.IntegrationRecipeManager;
+import buildcraft.core.recipes.ProgrammingRecipeManager;
 import buildcraft.core.recipes.RefineryRecipeManager;
 import buildcraft.core.render.BlockHighlightHandler;
 import buildcraft.core.statements.ActionMachineControl;
@@ -302,6 +303,7 @@ public class BuildCraftCore extends BuildCraftMod {
 		BuildcraftRecipeRegistry.assemblyTable = AssemblyRecipeManager.INSTANCE;
 		BuildcraftRecipeRegistry.integrationTable = IntegrationRecipeManager.INSTANCE;
 		BuildcraftRecipeRegistry.refinery = RefineryRecipeManager.INSTANCE;
+		BuildcraftRecipeRegistry.programmingTable = ProgrammingRecipeManager.INSTANCE;
 
 		BuildcraftFuelRegistry.fuel = FuelManager.INSTANCE;
 		BuildcraftFuelRegistry.coolant = CoolantManager.INSTANCE;

common/buildcraft/BuildCraftSilicon.java

@@ -96,7 +96,8 @@ import buildcraft.silicon.TileAssemblyTable;
 import buildcraft.silicon.TileChargingTable;
 import buildcraft.silicon.TileIntegrationTable;
 import buildcraft.silicon.TileLaser;
-import buildcraft.silicon.boards.BoardRecipe;
+import buildcraft.silicon.TileProgrammingTable;
+import buildcraft.silicon.boards.BoardProgrammingRecipe;
 import buildcraft.silicon.boards.ImplRedstoneBoardRegistry;
 import buildcraft.silicon.network.PacketHandlerSilicon;
 
@@ -220,6 +221,8 @@ public class BuildCraftSilicon extends BuildCraftMod {
 				"net.minecraft.src.buildcraft.factory.TileIntegrationTable");
         CoreProxy.proxy.registerTileEntity(TileChargingTable.class,
                 "net.minecraft.src.buildcraft.factory.TileChargingTable");
+		CoreProxy.proxy.registerTileEntity(TileProgrammingTable.class,
+				"net.minecraft.src.buildcraft.factory.TileProgrammingTable");
 		CoreProxy.proxy.registerTileEntity(TileZonePlan.class, "net.minecraft.src.buildcraft.commander.TileZonePlan");
 		CoreProxy.proxy.registerTileEntity(TileRequester.class, "net.minecraft.src.buildcraft.commander.TileRequester");
 
@@ -279,6 +282,15 @@ public class BuildCraftSilicon extends BuildCraftMod {
 				'C', new ItemStack(redstoneChipset, 1, 0),
 				'G', "gearGold");
 
+		CoreProxy.proxy.addCraftingRecipe(new ItemStack(assemblyTableBlock, 1, 4),
+				"ORO",
+				"OCO",
+				"OGO",
+				'O', Blocks.obsidian,
+				'R', "dustRedstone",
+				'C', Items.emerald,
+				'G', "gearDiamond");
+
 		// COMMANDER BLOCKS
 		CoreProxy.proxy.addCraftingRecipe(new ItemStack(zonePlanBlock, 1, 0),
 				"IRI",
@@ -338,7 +350,7 @@ public class BuildCraftSilicon extends BuildCraftMod {
 				'R', redstoneCrystal,
 				'C', Chipset.DIAMOND.getStack());
 
-		BuildcraftRecipeRegistry.assemblyTable.addRecipe(new BoardRecipe("buildcraft:redstoneBoard"));
+		BuildcraftRecipeRegistry.programmingTable.addRecipe(new BoardProgrammingRecipe());
 		BuildcraftRecipeRegistry.integrationTable.addRecipe(new RobotIntegrationRecipe("buildcraft:robotIntegration"));
 	}
 

common/buildcraft/core/recipes/ProgrammingRecipeManager.java

@@ -0,0 +1,50 @@
+package buildcraft.core.recipes;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import buildcraft.api.core.BCLog;
+import buildcraft.api.recipes.IProgrammingRecipe;
+import buildcraft.api.recipes.IProgrammingRecipeManager;
+
+public class ProgrammingRecipeManager implements IProgrammingRecipeManager {
+	public static final ProgrammingRecipeManager INSTANCE = new ProgrammingRecipeManager();
+	private final HashMap<String, IProgrammingRecipe> recipes = new HashMap<String, IProgrammingRecipe>();
+
+	@Override
+	public void addRecipe(IProgrammingRecipe recipe) {
+		if (recipe == null || recipe.getId() == null) {
+			return;
+		}
+
+		if (!recipes.containsKey(recipe.getId())) {
+			recipes.put(recipe.getId(), recipe);
+		} else {
+			BCLog.logger.warn("Programming Table Recipe '" + recipe.getId() + "' seems to be duplicated! This is a bug!");
+		}
+	}
+
+	@Override
+	public void removeRecipe(String id) {
+		recipes.remove(id);
+	}
+
+	@Override
+	public void removeRecipe(IProgrammingRecipe recipe) {
+		if (recipe == null || recipe.getId() == null) {
+			return;
+		}
+
+		recipes.remove(recipe.getId());
+	}
+
+	@Override
+	public Collection<IProgrammingRecipe> getRecipes() {
+		return Collections.unmodifiableCollection(recipes.values());
+	}
+
+	@Override
+	public IProgrammingRecipe getRecipe(String id) {
+		return recipes.get(id);
+	}
+}

common/buildcraft/silicon/BlockLaserTable.java

@@ -33,8 +33,9 @@ import buildcraft.core.CreativeTabBuildCraft;
 import buildcraft.core.utils.Utils;
 
 public class BlockLaserTable extends BlockBuildCraft implements ILaserTargetBlock {
-    protected static final int TABLE_MAX = 4;
+    protected static final int TABLE_MAX = 5;
 
+	private static final String[] ICON_NAMES = {"assemblytable", "advworkbenchtable", "integrationtable", "chargingtable", "programmingtable"};
 	@SideOnly(Side.CLIENT)
 	private IIcon[][] icons;
 
@@ -107,6 +108,8 @@ public class BlockLaserTable extends BlockBuildCraft implements ILaserTargetBloc
 				return new TileIntegrationTable();
             case 3:
                 return new TileChargingTable();
+			case 4:
+				return new TileProgrammingTable();
 		}
 		return null;
 	}
@@ -136,22 +139,9 @@ public class BlockLaserTable extends BlockBuildCraft implements ILaserTargetBloc
 		icons = new IIcon[TABLE_MAX][];
         for (int i = 0; i < TABLE_MAX; i++) {
             icons[i] = new IIcon[3];
+			icons[i][0] = par1IconRegister.registerIcon("buildcraft:" + ICON_NAMES[i] + "_bottom");
+			icons[i][1] = par1IconRegister.registerIcon("buildcraft:" + ICON_NAMES[i] + "_top");
+			icons[i][2] = par1IconRegister.registerIcon("buildcraft:" + ICON_NAMES[i] + "_side");
         }
-
-		icons[0][0] = par1IconRegister.registerIcon("buildcraft:assemblytable_bottom");
-		icons[0][1] = par1IconRegister.registerIcon("buildcraft:assemblytable_top");
-		icons[0][2] = par1IconRegister.registerIcon("buildcraft:assemblytable_side");
-
-		icons[1][0] = par1IconRegister.registerIcon("buildcraft:advworkbenchtable_bottom");
-		icons[1][1] = par1IconRegister.registerIcon("buildcraft:advworkbenchtable_top");
-		icons[1][2] = par1IconRegister.registerIcon("buildcraft:advworkbenchtable_side");
-
-		icons[2][0] = par1IconRegister.registerIcon("buildcraft:integrationtable_bottom");
-		icons[2][1] = par1IconRegister.registerIcon("buildcraft:integrationtable_top");
-		icons[2][2] = par1IconRegister.registerIcon("buildcraft:integrationtable_side");
-
-        icons[3][0] = par1IconRegister.registerIcon("buildcraft:chargingtable_bottom");
-        icons[3][1] = par1IconRegister.registerIcon("buildcraft:chargingtable_top");
-        icons[3][2] = par1IconRegister.registerIcon("buildcraft:chargingtable_side");
 	}
 }

common/buildcraft/silicon/GuiHandler.java

@@ -18,10 +18,12 @@ import buildcraft.silicon.gui.ContainerAdvancedCraftingTable;
 import buildcraft.silicon.gui.ContainerAssemblyTable;
 import buildcraft.silicon.gui.ContainerChargingTable;
 import buildcraft.silicon.gui.ContainerIntegrationTable;
+import buildcraft.silicon.gui.ContainerProgrammingTable;
 import buildcraft.silicon.gui.GuiAdvancedCraftingTable;
 import buildcraft.silicon.gui.GuiAssemblyTable;
 import buildcraft.silicon.gui.GuiChargingTable;
 import buildcraft.silicon.gui.GuiIntegrationTable;
+import buildcraft.silicon.gui.GuiProgrammingTable;
 
 public class GuiHandler implements IGuiHandler {
 
@@ -63,6 +65,13 @@ public class GuiHandler implements IGuiHandler {
                 return new GuiChargingTable(player.inventory, (TileChargingTable) tile);
             }
 
+		case 4:
+			if (!(tile instanceof TileProgrammingTable)) {
+				return null;
+			} else {
+				return new GuiProgrammingTable(player.inventory, (TileProgrammingTable) tile);
+			}
+
         default:
 			return null;
 		}
@@ -106,6 +115,13 @@ public class GuiHandler implements IGuiHandler {
                 return new ContainerChargingTable(player.inventory, (TileChargingTable) tile);
             }
 
+		case 4:
+			if (!(tile instanceof TileProgrammingTable)) {
+				return null;
+			} else {
+				return new ContainerProgrammingTable(player.inventory, (TileProgrammingTable) tile);
+			}
+
 		default:
 			return null;
 		}

common/buildcraft/silicon/ItemLaserTable.java

@@ -32,6 +32,8 @@ public class ItemLaserTable extends ItemBlockBuildCraft {
 				return "tile.integrationTableBlock";
             case 3:
                 return "tile.chargingTableBlock";
+			case 4:
+				return "tile.programmingTableBlock";
 		}
 		return super.getUnlocalizedName();
 	}

common/buildcraft/silicon/ItemRedstoneBoard.java

@@ -86,4 +86,8 @@ public class ItemRedstoneBoard extends ItemBuildCraft {
 			itemList.add(stack.copy());
 		}
 	}
+
+	public static boolean isClean(ItemStack stack) {
+		return !stack.hasTagCompound() || !stack.getTagCompound().hasKey("id");
+	}
 }

common/buildcraft/silicon/TileProgrammingTable.java

@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+package buildcraft.silicon;
+
+import java.util.List;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.relauncher.Side;
+import net.minecraftforge.common.util.ForgeDirection;
+import buildcraft.BuildCraftCore;
+import buildcraft.api.recipes.BuildcraftRecipeRegistry;
+import buildcraft.api.recipes.IProgrammingRecipe;
+import buildcraft.core.network.CommandWriter;
+import buildcraft.core.network.ICommandReceiver;
+import buildcraft.core.network.PacketCommand;
+import buildcraft.core.utils.StringUtils;
+import buildcraft.core.utils.Utils;
+
+public class TileProgrammingTable extends TileLaserTableBase implements IInventory, ISidedInventory, ICommandReceiver {
+	public static final int WIDTH = 6;
+	public static final int HEIGHT = 4;
+
+	public String currentRecipeId = "";
+	public IProgrammingRecipe currentRecipe;
+	public List<ItemStack> options;
+	public int optionId;
+	private boolean queuedNetworkUpdate = false;
+
+	private void queueNetworkUpdate() {
+		queuedNetworkUpdate = true;
+	}
+
+	@Override
+	public boolean canUpdate() {
+		return !FMLCommonHandler.instance().getEffectiveSide().isClient();
+	}
+
+	@Override
+	public void updateEntity() { // WARNING: run only server-side, see canUpdate()
+		super.updateEntity();
+
+		if (queuedNetworkUpdate) {
+			sendNetworkUpdate();
+			queuedNetworkUpdate = false;
+		}
+
+		if (currentRecipe == null) {
+			return;
+		}
+
+		if (this.getStackInSlot(0) == null || !currentRecipe.canCraft(this.getStackInSlot(0))) {
+			findRecipe();
+
+			if (currentRecipe == null) {
+				return;
+			}
+		}
+
+		if (optionId >= 0 && this.getStackInSlot(1) == null && getEnergy() >= currentRecipe.getEnergyCost(options.get(optionId))) {
+			setEnergy(0);
+
+			if (currentRecipe.canCraft(this.getStackInSlot(0))) {
+				ItemStack remaining = currentRecipe.craft(this.getStackInSlot(0), options.get(optionId));
+				this.setInventorySlotContents(0, null);
+
+				if (remaining != null && remaining.stackSize > 0) {
+					remaining.stackSize -= Utils
+							.addToRandomInventoryAround(worldObj, xCoord, yCoord, zCoord, remaining);
+				}
+
+				if (remaining != null && remaining.stackSize > 0) {
+					remaining.stackSize -= Utils.addToRandomInjectableAround(worldObj, xCoord, yCoord, zCoord, ForgeDirection.UNKNOWN, remaining);
+				}
+
+				if (remaining != null && remaining.stackSize > 0) {
+					EntityItem entityitem = new EntityItem(worldObj, xCoord + 0.5, yCoord + 0.7, zCoord + 0.5,
+							remaining);
+
+					worldObj.spawnEntityInWorld(entityitem);
+				}
+
+				if (remaining != null && remaining.stackSize > 0) {
+					this.setInventorySlotContents(1, remaining);
+				}
+
+				findRecipe();
+			}
+		}
+	}
+
+	/* IINVENTORY */
+	@Override
+	public int getSizeInventory() {
+		return 2;
+	}
+
+	@Override
+	public void setInventorySlotContents(int slot, ItemStack stack) {
+		super.setInventorySlotContents(slot, stack);
+
+		if (slot == 0) {
+			findRecipe();
+		}
+	}
+
+	@Override
+	public String getInventoryName() {
+		return StringUtils.localize("tile.programmingTableBlock.name");
+	}
+
+	@Override
+	public void readData(ByteBuf stream) {
+		super.readData(stream);
+		currentRecipeId = Utils.readUTF(stream);
+		optionId = stream.readUnsignedByte();
+		updateRecipe();
+	}
+
+	@Override
+	public void writeData(ByteBuf stream) {
+		super.writeData(stream);
+		Utils.writeUTF(stream, currentRecipeId);
+		stream.writeByte(optionId);
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound nbt) {
+		super.readFromNBT(nbt);
+
+		if (nbt.hasKey("recipeId") && nbt.hasKey("optionId")) {
+			currentRecipeId = nbt.getString("recipeId");
+			optionId = nbt.getInteger("optionId");
+		} else {
+			currentRecipeId = null;
+		}
+		updateRecipe();
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound nbt) {
+		super.writeToNBT(nbt);
+
+		if (currentRecipeId != null) {
+			nbt.setString("recipeId", currentRecipeId);
+			nbt.setByte("optionId", (byte) optionId);
+		}
+	}
+
+	@Override
+	public int getRequiredEnergy() {
+		if (hasWork()) {
+			return currentRecipe.getEnergyCost(options.get(optionId));
+		} else {
+			return 0;
+		}
+	}
+
+	public void findRecipe() {
+		String oldId = currentRecipeId;
+		currentRecipeId = null;
+
+		if (getStackInSlot(0) != null) {
+			for (IProgrammingRecipe recipe : BuildcraftRecipeRegistry.programmingTable.getRecipes()) {
+				if (recipe.canCraft(getStackInSlot(0))) {
+					currentRecipeId = recipe.getId();
+				}
+			}
+		}
+
+		if ((oldId != null && !oldId.equals(currentRecipeId)) || (oldId == null && currentRecipeId != null)) {
+			optionId = -1;
+			updateRecipe();
+			queueNetworkUpdate();
+		}
+	}
+
+	public void updateRecipe() {
+		currentRecipe = BuildcraftRecipeRegistry.programmingTable.getRecipe(currentRecipeId);
+		if (currentRecipe != null) {
+			options = currentRecipe.getOptions(WIDTH, HEIGHT);
+		} else {
+			options = null;
+		}
+	}
+
+	public void rpcSelectOption(final int pos) {
+		BuildCraftCore.instance.sendToServer(new PacketCommand(this, "select", new CommandWriter() {
+			public void write(ByteBuf data) {
+				data.writeByte(pos);
+			}
+		}));
+	}
+
+	@Override
+	public void receiveCommand(String command, Side side, Object sender, ByteBuf stream) {
+		if (side.isServer() && "select".equals(command)) {
+			optionId = stream.readUnsignedByte();
+			if (optionId >= options.size()) {
+				optionId = 0;
+			}
+
+			queueNetworkUpdate();
+		}
+	}
+
+	@Override
+	public boolean hasWork() {
+		return currentRecipe != null && optionId >= 0;
+	}
+
+	@Override
+	public boolean canCraft() {
+		return hasWork();
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int slot, ItemStack stack) {
+		return (slot == 0 || stack == null);
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return false;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int side) {
+		return new int[] {0, 1};
+	}
+
+	@Override
+	public boolean canInsertItem(int slot, ItemStack stack, int side) {
+		return slot == 0;
+	}
+
+	@Override
+	public boolean canExtractItem(int slot, ItemStack stack, int side) {
+		return slot == 1;
+	}
+}

common/buildcraft/silicon/boards/BoardProgrammingRecipe.java

@@ -0,0 +1,65 @@
+package buildcraft.silicon.boards;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import buildcraft.BuildCraftSilicon;
+import buildcraft.api.boards.RedstoneBoardNBT;
+import buildcraft.api.boards.RedstoneBoardRegistry;
+import buildcraft.api.recipes.IProgrammingRecipe;
+import buildcraft.core.utils.NBTUtils;
+import buildcraft.silicon.ItemRedstoneBoard;
+
+/**
+ * Created by asie on 2/24/15.
+ */
+public class BoardProgrammingRecipe implements IProgrammingRecipe {
+	private class BoardSorter implements Comparator<ItemStack> {
+		private BoardProgrammingRecipe recipe;
+
+		public BoardSorter(BoardProgrammingRecipe recipe) {
+			this.recipe = recipe;
+		}
+
+		@Override
+		public int compare(ItemStack o1, ItemStack o2) {
+			return recipe.getEnergyCost(o1) - recipe.getEnergyCost(o2);
+		}
+	}
+
+	@Override
+	public String getId() {
+		return "buildcraft:redstone_board";
+	}
+
+	@Override
+	public List<ItemStack> getOptions(int width, int height) {
+		List<ItemStack> options = new ArrayList<ItemStack>(width * height);
+		for (RedstoneBoardNBT nbt : RedstoneBoardRegistry.instance.getAllBoardNBTs()) {
+			ItemStack stack = new ItemStack(BuildCraftSilicon.redstoneBoard);
+			nbt.createBoard(NBTUtils.getItemData(stack));
+			options.add(stack);
+		}
+		options.sort(new BoardSorter(this));
+		return options;
+	}
+
+	@Override
+	public int getEnergyCost(ItemStack option) {
+		// TODO: Replace probability with proper energy cost? (7.0.x?)
+		ImplRedstoneBoardRegistry impl = (ImplRedstoneBoardRegistry) RedstoneBoardRegistry.instance;
+		return Math.round((20.0F / impl.getProbability(option.getTagCompound().getString("id"))) * 8000);
+	}
+
+	@Override
+	public boolean canCraft(ItemStack input) {
+		return (input.getItem() instanceof ItemRedstoneBoard);
+	}
+
+	@Override
+	public ItemStack craft(ItemStack input, ItemStack option) {
+		return option;
+	}
+}

common/buildcraft/silicon/boards/BoardRecipe.java

@@ -1,49 +0,0 @@
-/**
- * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
- * http://www.mod-buildcraft.com
- *
- * BuildCraft is distributed under the terms of the Minecraft Mod Public
- * License 1.0, or MMPL. Please check the contents of the license located in
- * http://www.mod-buildcraft.com/MMPL-1.0.txt
- */
-package buildcraft.silicon.boards;
-
-import net.minecraft.item.ItemStack;
-
-import buildcraft.BuildCraftSilicon;
-import buildcraft.api.boards.RedstoneBoardRegistry;
-import buildcraft.api.recipes.CraftingResult;
-import buildcraft.api.recipes.IFlexibleCrafter;
-import buildcraft.core.recipes.FlexibleRecipe;
-import buildcraft.core.utils.NBTUtils;
-
-public class BoardRecipe extends FlexibleRecipe {
-
-	public BoardRecipe(String id) {
-		ItemStack output = new ItemStack(BuildCraftSilicon.redstoneBoard);
-		NBTUtils.getItemData(output).setString("id", "<unknown>");
-
-		setContents(id, output, 1000, 0, new ItemStack(BuildCraftSilicon.redstoneBoard));
-	}
-
-	@Override
-	public CraftingResult<ItemStack> craft(IFlexibleCrafter crafter, boolean preview) {
-		CraftingResult<ItemStack> result = super.craft(crafter, preview);
-
-		if (result != null) {
-			ItemStack stack = new ItemStack(BuildCraftSilicon.redstoneBoard);
-			RedstoneBoardRegistry.instance.createRandomBoard(NBTUtils.getItemData(stack));
-
-			result.crafted = stack;
-
-			return result;
-		} else {
-			return null;
-		}
-	}
-
-	@Override
-	public CraftingResult canCraft(ItemStack expectedOutput) {
-		return null;
-	}
-}

common/buildcraft/silicon/boards/ImplRedstoneBoardRegistry.java

@@ -96,4 +96,9 @@ public class ImplRedstoneBoardRegistry extends RedstoneBoardRegistry {
 
 		return result;
 	}
+
+	// TODO: Publicize this in the abstract class (6.5.0)
+	public float getProbability(String id) {
+		return boards.get(id) != null ? boards.get(id).probability : 0;
+	}
 }

common/buildcraft/silicon/gui/ContainerProgrammingTable.java

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+package buildcraft.silicon.gui;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.ICrafting;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import buildcraft.core.gui.BuildCraftContainer;
+import buildcraft.silicon.TileProgrammingTable;
+
+public class ContainerProgrammingTable extends BuildCraftContainer {
+	IInventory playerIInventory;
+	TileProgrammingTable table;
+
+	public ContainerProgrammingTable(IInventory playerInventory, TileProgrammingTable table) {
+		super(table.getSizeInventory());
+		this.playerIInventory = playerInventory;
+
+		addSlotToContainer(new Slot(table, 0, 8, 36));
+		addSlotToContainer(new Slot(table, 1, 8, 90));
+
+		for (int l = 0; l < 3; l++) {
+			for (int k1 = 0; k1 < 9; k1++) {
+				addSlotToContainer(new Slot(playerInventory, k1 + l * 9 + 9, 8 + k1 * 18, 123 + l * 18));
+			}
+
+		}
+
+		for (int i1 = 0; i1 < 9; i1++) {
+			addSlotToContainer(new Slot(playerInventory, i1, 8 + i1 * 18, 181));
+		}
+
+		this.table = table;
+	}
+
+	@Override
+	public boolean canInteractWith(EntityPlayer entityplayer) {
+		return table.isUseableByPlayer(entityplayer);
+	}
+
+	@Override
+	public void updateProgressBar(int i, int j) {
+		table.getGUINetworkData(i, j);
+	}
+
+	@Override
+	public void detectAndSendChanges() {
+		super.detectAndSendChanges();
+
+		for (int i = 0; i < crafters.size(); i++) {
+			table.sendGUINetworkData(this, (ICrafting) crafters.get(i));
+		}
+	}
+}

common/buildcraft/silicon/gui/GuiProgrammingTable.java

@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2011-2014, SpaceToad and the BuildCraft Team
+ * http://www.mod-buildcraft.com
+ *
+ * BuildCraft is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://www.mod-buildcraft.com/MMPL-1.0.txt
+ */
+package buildcraft.silicon.gui;
+
+import java.util.Iterator;
+import java.util.List;
+import org.lwjgl.opengl.GL11;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import buildcraft.BuildCraftCore;
+import buildcraft.api.recipes.CraftingResult;
+import buildcraft.core.CoreIconProvider;
+import buildcraft.core.DefaultProps;
+import buildcraft.core.gui.AdvancedSlot;
+import buildcraft.core.gui.GuiAdvancedInterface;
+import buildcraft.core.utils.StringUtils;
+import buildcraft.silicon.TileProgrammingTable;
+
+public class GuiProgrammingTable extends GuiAdvancedInterface {
+
+	private static final ResourceLocation TEXTURE = new ResourceLocation("buildcraft", DefaultProps.TEXTURE_PATH_GUI + "/programming_table.png");
+
+	private class LaserTableLedger extends Ledger {
+
+		int headerColour = 0xe1c92f;
+		int subheaderColour = 0xaaafb8;
+		int textColour = 0x000000;
+
+		public LaserTableLedger() {
+			maxHeight = 94;
+			overlayColor = 0xd46c1f;
+		}
+
+		@Override
+		public void draw(int x, int y) {
+
+			// Draw background
+			drawBackground(x, y);
+
+			// Draw icon
+			Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);
+			drawIcon(BuildCraftCore.iconProvider.getIcon(CoreIconProvider.ENERGY), x + 3, y + 4);
+
+			if (!isFullyOpened()) {
+				return;
+			}
+
+			fontRendererObj.drawStringWithShadow(StringUtils.localize("gui.energy"), x + 22, y + 8, headerColour);
+			fontRendererObj.drawStringWithShadow(StringUtils.localize("gui.assemblyCurrentRequired") + ":", x + 22, y + 20, subheaderColour);
+			fontRendererObj.drawString(String.format("%d RF", table.clientRequiredEnergy), x + 22, y + 32, textColour);
+			fontRendererObj.drawStringWithShadow(StringUtils.localize("gui.stored") + ":", x + 22, y + 44, subheaderColour);
+			fontRendererObj.drawString(String.format("%d RF", table.getEnergy()), x + 22, y + 56, textColour);
+			fontRendererObj.drawStringWithShadow(StringUtils.localize("gui.assemblyRate") + ":", x + 22, y + 68, subheaderColour);
+			fontRendererObj.drawString(String.format("%.1f RF/t", table.getRecentEnergyAverage() / 100.0f), x + 22, y + 80, textColour);
+
+		}
+
+		@Override
+		public String getTooltip() {
+			return String.format("%.1f RF/t", table.getRecentEnergyAverage() / 100.0f);
+		}
+	}
+	private final TileProgrammingTable table;
+
+	class RecipeSlot extends AdvancedSlot {
+		public ItemStack slot;
+		public int id;
+
+		public RecipeSlot(int x, int y, int i) {
+			super(GuiProgrammingTable.this, x, y);
+			id = i;
+		}
+
+		@Override
+		public ItemStack getItemStack() {
+			return slot;
+		}
+	}
+
+	public GuiProgrammingTable(IInventory playerInventory, TileProgrammingTable programmingTable) {
+		super(new ContainerProgrammingTable(playerInventory, programmingTable), programmingTable, TEXTURE);
+
+		this.table = programmingTable;
+		xSize = 176;
+		ySize = 207;
+
+		for (int j = 0; j < TileProgrammingTable.HEIGHT; ++j) {
+			for (int i = 0; i < TileProgrammingTable.WIDTH; ++i) {
+				slots.add(new RecipeSlot(43 + 18 * i, 36 + 18 * j, (j * TileProgrammingTable.WIDTH) + i));
+			}
+		}
+
+		updateRecipes();
+	}
+
+	public void updateRecipes() {
+		if (table.options != null) {
+			Iterator<ItemStack> cur = table.options.iterator();
+
+			for (AdvancedSlot s : slots) {
+				if (cur.hasNext()) {
+					((RecipeSlot) s).slot = cur.next();
+				} else {
+					((RecipeSlot) s).slot = null;
+				}
+			}
+		} else {
+			for (AdvancedSlot s : slots) {
+				((RecipeSlot) s).slot = null;
+			}
+		}
+	}
+
+	@Override
+	protected void drawGuiContainerForegroundLayer(int par1, int par2) {
+		super.drawGuiContainerForegroundLayer(par1, par2);
+		String title = StringUtils.localize("tile.programmingTableBlock.name");
+		fontRendererObj.drawString(title, getCenteredOffset(title), 15, 0x404040);
+		fontRendererObj.drawString(StringUtils.localize("gui.inventory"), 8, ySize - 97, 0x404040);
+		drawTooltipForSlotAt(par1, par2);
+	}
+
+	@Override
+	protected void drawGuiContainerBackgroundLayer(float f, int x, int y) {
+		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+		mc.renderEngine.bindTexture(TEXTURE);
+		drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize);
+
+		updateRecipes();
+
+		int i = 0;
+
+		for (AdvancedSlot slot2 : slots) {
+			RecipeSlot slot = (RecipeSlot) slot2;
+
+			if (slot.slot != null) {
+				if (table.optionId == i) {
+					drawTexturedModalRect(guiLeft + slot.x, guiTop + slot.y, 196, 1, 16, 16);
+				}
+			}
+			i++;
+		}
+
+		int h = table.getProgressScaled(70);
+
+		drawTexturedModalRect(guiLeft + 164, guiTop + 36 + 70 - h, 176, 18, 4, h);
+
+		drawBackgroundSlots();
+	}
+
+	@Override
+	protected void slotClicked(AdvancedSlot aslot, int mouseButton) {
+		super.slotClicked(aslot, mouseButton);
+		
+		if (aslot instanceof RecipeSlot) {
+			RecipeSlot slot = (RecipeSlot) aslot;
+			
+			if (slot.slot == null) {
+				return;
+			}
+
+			table.rpcSelectOption(slot.id);
+		}
+	}
+
+	@Override
+	protected void initLedgers(IInventory inventory) {
+		super.initLedgers(inventory);
+		if (!BuildCraftCore.hidePowerNumbers) {
+			ledgerManager.add(new LaserTableLedger());
+		}
+	}
+}