Inventory scrolling robot GUI.

Limiting maximum inventory space in robots (regardless of number of upgrades) to 64.

src/main/scala/li/cil/oc/client/PacketSender.scala

@@ -1,8 +1,8 @@
 package li.cil.oc.client
 
 import li.cil.oc.common.tileentity._
-import li.cil.oc.common.tileentity.traits.{Computer, TextBuffer}
+import li.cil.oc.common.tileentity.traits.Computer
-import li.cil.oc.common.{CompressedPacketBuilder, PacketBuilder, PacketType, component}
+import li.cil.oc.common.{CompressedPacketBuilder, PacketBuilder, PacketType}
 import net.minecraft.client.Minecraft
 import net.minecraftforge.common.ForgeDirection
 

src/main/scala/li/cil/oc/client/gui/ImageButton.scala

@@ -17,6 +17,8 @@ class ImageButton(id: Int, x: Int, y: Int, w: Int, h: Int,
 
   var toggled = false
 
+  var hoverOverride = false
+
   override def drawButton(mc: Minecraft, mouseX: Int, mouseY: Int) {
     if (drawButton) {
       mc.renderEngine.bindTexture(image)
@@ -30,7 +32,7 @@ class ImageButton(id: Int, x: Int, y: Int, w: Int, h: Int,
 
       val u0 = if (toggled) 0.5 else 0
       val u1 = u0 + (if (canToggle) 0.5 else 1)
-      val v0 = if (getHoverState(field_82253_i) == 2) 0.5 else 0
+      val v0 = if (hoverOverride || getHoverState(field_82253_i) == 2) 0.5 else 0
       val v1 = v0 + 0.5
 
       val t = Tessellator.instance
@@ -44,7 +46,7 @@ class ImageButton(id: Int, x: Int, y: Int, w: Int, h: Int,
       if (displayString != null) {
         val color =
           if (!enabled) textDisabledColor
-          else if (field_82253_i) textHoverColor
+          else if (hoverOverride || field_82253_i) textHoverColor
           else textColor
         drawCenteredString(mc.fontRenderer, displayString, xPosition + width / 2, yPosition + (height - 8) / 2, color)
       }

src/main/scala/li/cil/oc/client/gui/Robot.scala

@@ -17,7 +17,7 @@ import net.minecraft.client.renderer.texture.TextureMap
 import net.minecraft.entity.player.InventoryPlayer
 import net.minecraft.inventory.Slot
 import net.minecraft.util.StatCollector
-import org.lwjgl.input.Keyboard
+import org.lwjgl.input.{Mouse, Keyboard}
 import org.lwjgl.opengl.GL11
 
 class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) extends CustomGuiContainer(new container.Robot(playerInventory, robot)) with TextBuffer {
@@ -36,13 +36,24 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
 
   // Scroll offset for robot inventory.
   private var inventoryOffset = 0
+  private var isDragging = false
+
+  private def canScroll = robot.inventorySize > 16
+  private def maxOffset = robot.inventorySize / 4 - 4
+
+  private val slotSize = 18
 
   private val bufferWidth = 242.0
   private val bufferHeight = 128.0
   private val bufferMargin = BufferRenderer.innerMargin
 
-  private val inventoryX = 168
+  private val inventoryX = 169
-  private val inventoryY = 140
+  private val inventoryY = 141
+
+  private val scrollX = inventoryX + slotSize * 4 + 2
+  private val scrollY = inventoryY
+  private val scrollWidth = 8
+  private val scrollHeight = 94
 
   private val powerX = 26
   private val powerY = 142
@@ -64,14 +75,18 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
 
   override def drawScreen(mouseX: Int, mouseY: Int, dt: Float) {
     powerButton.toggled = robot.isRunning
-    scrollButton.enabled = robot.inventorySize > 16
+    scrollButton.enabled = canScroll
+    scrollButton.hoverOverride = isDragging
+    if (robot.inventorySize < 16 + inventoryOffset * 4) {
+      scrollTo(0)
+    }
     super.drawScreen(mouseX, mouseY, dt)
   }
 
   override def initGui() {
     super.initGui()
     powerButton = new ImageButton(0, guiLeft + 5, guiTop + 139, 18, 18, Textures.guiButtonPower, canToggle = true)
-    scrollButton = new ImageButton(1, guiLeft + 244, guiTop + 142, 6, 13, Textures.guiButtonScroll)
+    scrollButton = new ImageButton(1, guiLeft + scrollX + 1, guiTop + scrollY + 1, 6, 13, Textures.guiButtonScroll)
     add(buttonList, powerButton)
     add(buttonList, scrollButton)
   }
@@ -149,6 +164,80 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
     }
   }
 
+  override protected def mouseClicked(mouseX: Int, mouseY: Int, button: Int) {
+    super.mouseClicked(mouseX, mouseY, button)
+    if (canScroll && button == 0 && isCoordinateOverScrollBar(mouseX - guiLeft, mouseY - guiTop)) {
+      isDragging = true
+      scrollMouse(mouseY)
+    }
+  }
+
+  override def mouseMovedOrUp(mouseX: Int, mouseY: Int, button: Int) {
+    super.mouseMovedOrUp(mouseX, mouseY, button)
+    if (button == 0) {
+      isDragging = false
+    }
+  }
+
+  override def mouseClickMove(mouseX: Int, mouseY: Int, lastButtonClicked: Int, timeSinceMouseClick: Long) {
+    super.mouseClickMove(mouseX, mouseY, lastButtonClicked, timeSinceMouseClick)
+    if (isDragging) {
+      scrollMouse(mouseY)
+    }
+  }
+
+  private def scrollMouse(mouseY: Int) {
+    scrollTo(math.round((mouseY - guiTop - scrollY + 1 - 6.5) * maxOffset / (scrollHeight - 13.0)).toInt)
+  }
+
+  override def handleMouseInput() {
+    super.handleMouseInput()
+    if (Mouse.hasWheel && Mouse.getEventDWheel != 0) {
+      val mouseX = Mouse.getEventX * width / mc.displayWidth - guiLeft
+      val mouseY = height - Mouse.getEventY * height / mc.displayHeight - 1 - guiTop
+      if (isCoordinateOverInventory(mouseX, mouseY) || isCoordinateOverScrollBar(mouseX, mouseY)) {
+        if (math.signum(Mouse.getEventDWheel) < 0) scrollDown()
+        else scrollUp()
+      }
+    }
+  }
+
+  private def isCoordinateOverInventory(x: Int, y: Int) =
+    x >= inventoryX && x < inventoryX + slotSize * 4 &&
+      y >= inventoryY && y < inventoryY + slotSize * 4
+
+  private def isCoordinateOverScrollBar(x: Int, y: Int) =
+    x > scrollX && x < scrollX + scrollWidth &&
+      y >= scrollY && y < scrollY + scrollHeight
+
+  private def scrollUp() = scrollTo(inventoryOffset - 1)
+
+  private def scrollDown() = scrollTo(inventoryOffset + 1)
+
+  private def scrollTo(row: Int) {
+    inventoryOffset = math.max(0, math.min(maxOffset, row))
+    for (index <- 4 until 68) {
+      val slot = inventorySlots.getSlot(index)
+      val displayIndex = index - inventoryOffset * 4 - 4
+      if (displayIndex >= 0 && displayIndex < 16) {
+        slot.xDisplayPosition = 1 + inventoryX + (displayIndex % 4) * slotSize
+        slot.yDisplayPosition = 1 + inventoryY + (displayIndex / 4) * slotSize
+      }
+      else {
+        // Hide the rest!
+        slot.xDisplayPosition = -10000
+        slot.yDisplayPosition = -10000
+      }
+    }
+    val yMin = guiTop + scrollY + 1
+    if (maxOffset > 0) {
+      scrollButton.yPosition = yMin + (scrollHeight - 15) * inventoryOffset / maxOffset
+    }
+    else {
+      scrollButton.yPosition = yMin
+    }
+  }
+
   override protected def changeSize(w: Double, h: Double) = {
     val bw = w * MonospaceFontRenderer.fontWidth
     val bh = h * MonospaceFontRenderer.fontHeight
@@ -158,13 +247,14 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
   }
 
   private def drawSelection() {
+    val slot = robot.selectedSlot - robot.actualSlot(0) - inventoryOffset * 4
+    if (slot >= 0 && slot < 16) {
       RenderState.makeItBlend()
       Minecraft.getMinecraft.renderEngine.bindTexture(Textures.guiRobotSelection)
       val now = System.currentTimeMillis() / 1000.0
       val offsetV = ((now - now.toInt) * selectionsStates).toInt * selectionStepV
-    val slot = robot.selectedSlot - robot.actualSlot(0)
+      val x = guiLeft + inventoryX - 1 + (slot % 4) * (selectionSize - 2)
-    val x = guiLeft + inventoryX + (slot % 4) * (selectionSize - 2)
+      val y = guiTop + inventoryY - 1 + (slot / 4) * (selectionSize - 2)
-    val y = guiTop + inventoryY + (slot / 4) * (selectionSize - 2)
 
       val t = Tessellator.instance
       t.startDrawingQuads()
@@ -174,6 +264,7 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
       t.addVertexWithUV(x + selectionSize, y, zLevel, 1, offsetV)
       t.draw()
     }
+  }
 
   private def drawPowerLevel() {
     val level = robot.globalBuffer / robot.globalBufferSize

src/main/scala/li/cil/oc/common/component/TextBuffer.scala

@@ -374,6 +374,8 @@ class TextBuffer(val owner: component.Container) extends ManagedComponent with a
 object TextBuffer {
 
   abstract class Proxy {
+    def owner: TextBuffer
+
     var dirty = false
 
     var nodeAddress = ""
@@ -382,17 +384,25 @@ object TextBuffer {
 
     def onScreenColorChange()
 
-    def onScreenCopy(col: Int, row: Int, w: Int, h: Int, tx: Int, ty: Int)
+    def onScreenCopy(col: Int, row: Int, w: Int, h: Int, tx: Int, ty: Int) {
+      owner.relativeLitArea = -1
+    }
 
     def onScreenDepthChange(depth: ColorDepth)
 
-    def onScreenFill(col: Int, row: Int, w: Int, h: Int, c: Char)
+    def onScreenFill(col: Int, row: Int, w: Int, h: Int, c: Char) {
+      owner.relativeLitArea = -1
+    }
 
     def onScreenPaletteChange(index: Int)
 
-    def onScreenResolutionChange(w: Int, h: Int)
+    def onScreenResolutionChange(w: Int, h: Int) {
+      owner.relativeLitArea = -1
+    }
 
-    def onScreenSet(col: Int, row: Int, s: String, vertical: Boolean)
+    def onScreenSet(col: Int, row: Int, s: String, vertical: Boolean) {
+      owner.relativeLitArea = -1
+    }
 
     def keyDown(character: Char, code: Int, player: EntityPlayer)
 
@@ -412,19 +422,37 @@ object TextBuffer {
   class ClientProxy(val owner: TextBuffer) extends Proxy {
     override def render() = TextBufferRenderCache.render(owner)
 
-    override def onScreenColorChange() = dirty = true
+    override def onScreenColorChange() {
+      dirty = true
+    }
 
-    override def onScreenCopy(col: Int, row: Int, w: Int, h: Int, tx: Int, ty: Int) = dirty = true
+    override def onScreenCopy(col: Int, row: Int, w: Int, h: Int, tx: Int, ty: Int) {
+      super.onScreenCopy(col, row, w, h, tx, ty)
+      dirty = true
+    }
 
-    override def onScreenDepthChange(depth: ColorDepth) = dirty = true
+    override def onScreenDepthChange(depth: ColorDepth) {
+      dirty = true
+    }
 
-    override def onScreenFill(col: Int, row: Int, w: Int, h: Int, c: Char) = dirty = true
+    override def onScreenFill(col: Int, row: Int, w: Int, h: Int, c: Char) {
+      super.onScreenFill(col, row, w, h, c)
+      dirty = true
+    }
 
-    override def onScreenPaletteChange(index: Int) = dirty = true
+    override def onScreenPaletteChange(index: Int) {
+      dirty = true
+    }
 
-    override def onScreenResolutionChange(w: Int, h: Int) = dirty = true
+    override def onScreenResolutionChange(w: Int, h: Int) {
+      super.onScreenResolutionChange(w, h)
+      dirty = true
+    }
 
-    override def onScreenSet(col: Int, row: Int, s: String, vertical: Boolean) = dirty = true
+    override def onScreenSet(col: Int, row: Int, s: String, vertical: Boolean) {
+      super.onScreenSet(col, row, s, vertical)
+      dirty = true
+    }
 
     override def keyDown(character: Char, code: Int, player: EntityPlayer) =
       ClientPacketSender.sendKeyDown(nodeAddress, character, code)
@@ -448,76 +476,76 @@ object TextBuffer {
       ClientPacketSender.sendMouseScroll(nodeAddress, x, y, delta)
   }
 
-  class ServerProxy(val buffer: TextBuffer) extends Proxy {
+  class ServerProxy(val owner: TextBuffer) extends Proxy {
     override def onScreenColorChange() {
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferColorChange(buffer.node.address, buffer.data.foreground, buffer.data.background, buffer.owner)
+      ServerPacketSender.sendTextBufferColorChange(owner.node.address, owner.data.foreground, owner.data.background, owner.owner)
     }
 
     override def onScreenCopy(col: Int, row: Int, w: Int, h: Int, tx: Int, ty: Int) {
-      buffer.relativeLitArea = -1
+      super.onScreenCopy(col, row, w, h, tx, ty)
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferCopy(buffer.node.address, col, row, w, h, tx, ty, buffer.owner)
+      ServerPacketSender.sendTextBufferCopy(owner.node.address, col, row, w, h, tx, ty, owner.owner)
     }
 
     override def onScreenDepthChange(depth: ColorDepth) {
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferDepthChange(buffer.node.address, depth, buffer.owner)
+      ServerPacketSender.sendTextBufferDepthChange(owner.node.address, depth, owner.owner)
     }
 
     override def onScreenFill(col: Int, row: Int, w: Int, h: Int, c: Char) {
-      buffer.relativeLitArea = -1
+      super.onScreenFill(col, row, w, h, c)
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferFill(buffer.node.address, col, row, w, h, c, buffer.owner)
+      ServerPacketSender.sendTextBufferFill(owner.node.address, col, row, w, h, c, owner.owner)
     }
 
     override def onScreenPaletteChange(index: Int) {
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferPaletteChange(buffer.node.address, index, buffer.getPaletteColor(index), buffer.owner)
+      ServerPacketSender.sendTextBufferPaletteChange(owner.node.address, index, owner.getPaletteColor(index), owner.owner)
     }
 
     override def onScreenResolutionChange(w: Int, h: Int) {
-      buffer.relativeLitArea = -1
+      super.onScreenResolutionChange(w, h)
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferResolutionChange(buffer.node.address, w, h, buffer.owner)
+      ServerPacketSender.sendTextBufferResolutionChange(owner.node.address, w, h, owner.owner)
     }
 
     override def onScreenSet(col: Int, row: Int, s: String, vertical: Boolean) {
-      buffer.relativeLitArea = -1
+      super.onScreenSet(col, row, s, vertical)
-      buffer.owner.markChanged()
+      owner.owner.markChanged()
-      ServerPacketSender.sendTextBufferSet(buffer.node.address, col, row, s, vertical, buffer.owner)
+      ServerPacketSender.sendTextBufferSet(owner.node.address, col, row, s, vertical, owner.owner)
     }
 
     override def keyDown(character: Char, code: Int, player: EntityPlayer) {
-      buffer.node.sendToVisible("keyboard.keyDown", player, Char.box(character), Int.box(code))
+      owner.node.sendToVisible("keyboard.keyDown", player, Char.box(character), Int.box(code))
     }
 
     override def keyUp(character: Char, code: Int, player: EntityPlayer) {
-      buffer.node.sendToVisible("keyboard.keyUp", player, Char.box(character), Int.box(code))
+      owner.node.sendToVisible("keyboard.keyUp", player, Char.box(character), Int.box(code))
     }
 
     override def clipboard(value: String, player: EntityPlayer) {
-      buffer.node.sendToVisible("keyboard.clipboard", player, value)
+      owner.node.sendToVisible("keyboard.clipboard", player, value)
     }
 
     override def mouseDown(x: Int, y: Int, button: Int, player: EntityPlayer) {
-      if (Settings.get.inputUsername) buffer.node.sendToReachable("computer.checked_signal", player, "touch", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
+      if (Settings.get.inputUsername) owner.node.sendToReachable("computer.checked_signal", player, "touch", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
-      else buffer.node.sendToReachable("computer.checked_signal", player, "touch", Int.box(x), Int.box(y), Int.box(button))
+      else owner.node.sendToReachable("computer.checked_signal", player, "touch", Int.box(x), Int.box(y), Int.box(button))
     }
 
     override def mouseDrag(x: Int, y: Int, button: Int, player: EntityPlayer) {
-      if (Settings.get.inputUsername) buffer.node.sendToReachable("computer.checked_signal", player, "drag", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
+      if (Settings.get.inputUsername) owner.node.sendToReachable("computer.checked_signal", player, "drag", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
-      else buffer.node.sendToReachable("computer.checked_signal", player, "drag", Int.box(x), Int.box(y), Int.box(button))
+      else owner.node.sendToReachable("computer.checked_signal", player, "drag", Int.box(x), Int.box(y), Int.box(button))
     }
 
     override def mouseUp(x: Int, y: Int, button: Int, player: EntityPlayer) {
-      if (Settings.get.inputUsername) buffer.node.sendToReachable("computer.checked_signal", player, "drop", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
+      if (Settings.get.inputUsername) owner.node.sendToReachable("computer.checked_signal", player, "drop", Int.box(x), Int.box(y), Int.box(button), player.getCommandSenderName)
-      else buffer.node.sendToReachable("computer.checked_signal", player, "drop", Int.box(x), Int.box(y), Int.box(button))
+      else owner.node.sendToReachable("computer.checked_signal", player, "drop", Int.box(x), Int.box(y), Int.box(button))
     }
 
     override def mouseScroll(x: Int, y: Int, delta: Int, player: EntityPlayer) {
-      if (Settings.get.inputUsername) buffer.node.sendToReachable("computer.checked_signal", player, "scroll", Int.box(x), Int.box(y), Int.box(delta), player.getCommandSenderName)
+      if (Settings.get.inputUsername) owner.node.sendToReachable("computer.checked_signal", player, "scroll", Int.box(x), Int.box(y), Int.box(delta), player.getCommandSenderName)
-      else buffer.node.sendToReachable("computer.checked_signal", player, "scroll", Int.box(x), Int.box(y), Int.box(delta))
+      else owner.node.sendToReachable("computer.checked_signal", player, "scroll", Int.box(x), Int.box(y), Int.box(delta))
     }
   }
 

src/main/scala/li/cil/oc/common/container/ComponentSlot.scala

@@ -3,7 +3,7 @@ package li.cil.oc.common.container
 import li.cil.oc.api
 import li.cil.oc.common.InventorySlots.Tier
 import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.inventory.Slot
+import net.minecraft.inventory.{IInventory, Slot}
 import net.minecraft.item.ItemStack
 import net.minecraft.util.Icon
 import scala.collection.convert.WrapAsScala._
@@ -18,6 +18,25 @@ trait ComponentSlot extends Slot {
 
   def tierIcon: Icon
 
+  // ----------------------------------------------------------------------- //
+
+  var slotIndex = super.getSlotIndex
+
+  override def getStack = inventory.getStackInSlot(slotIndex)
+
+  override def putStack(stack: ItemStack) {
+    inventory.setInventorySlotContents(slotIndex, stack)
+    onSlotChanged()
+  }
+
+  override def decrStackSize(amount: Int) = inventory.decrStackSize(slotIndex, amount)
+
+  override def isSlotInInventory(inventory: IInventory, slot: Int) = inventory == this.inventory && slot == slotIndex
+
+  override def getSlotIndex = slotIndex
+
+  // ----------------------------------------------------------------------- //
+
   @SideOnly(Side.CLIENT)
   override def func_111238_b() = tier != Tier.None && super.func_111238_b()
 

src/main/scala/li/cil/oc/common/container/Player.scala

@@ -2,13 +2,12 @@ package li.cil.oc.common.container
 
 import cpw.mods.fml.common.FMLCommonHandler
 import li.cil.oc.api
+import li.cil.oc.common.InventorySlots.{Tier, InventorySlot}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.entity.player.InventoryPlayer
-import net.minecraft.inventory.Container
+import net.minecraft.inventory.{ICrafting, Container, IInventory, Slot}
-import net.minecraft.inventory.IInventory
-import net.minecraft.inventory.Slot
 import net.minecraft.item.ItemStack
-import li.cil.oc.common.InventorySlots.{Tier, InventorySlot}
+import scala.collection.convert.WrapAsScala._
 
 abstract class Player(val playerInventory: InventoryPlayer, val otherInventory: IInventory) extends Container {
   /** Number of player inventory slots to display horizontally. */
@@ -117,4 +116,11 @@ abstract class Player(val playerInventory: InventoryPlayer, val otherInventory:
       addSlotToContainer(new Slot(playerInventory, index, x, y))
     }
   }
+
+  protected def sendProgressBarUpdate(id: Int, value: Int) {
+    for (entry <- crafters) entry match {
+      case player: ICrafting => player.sendProgressBarUpdate(this, id, value)
+      case _ =>
+    }
+  }
 }

src/main/scala/li/cil/oc/common/container/Robot.scala

@@ -6,8 +6,8 @@ import li.cil.oc.api
 import li.cil.oc.client.gui.Icons
 import li.cil.oc.common.tileentity
 import li.cil.oc.common.InventorySlots.Tier
-import li.cil.oc.server.{PacketSender => ServerPacketSender}
 import net.minecraft.entity.player.{EntityPlayer, InventoryPlayer}
+import net.minecraft.inventory.IInventory
 
 class Robot(playerInventory: InventoryPlayer, robot: tileentity.Robot) extends Player(playerInventory, robot) {
   addSlotToContainer(170 + 0 * slotSize, 218, api.driver.Slot.Tool)
@@ -19,8 +19,40 @@ class Robot(playerInventory: InventoryPlayer, robot: tileentity.Robot) extends P
     val y = 142 + i * slotSize
     for (j <- 0 to 3) {
       val x = 170 + j * slotSize
-      val index = inventorySlots.size
+      addSlotToContainer(new InventorySlot(this, otherInventory, inventorySlots.size, x, y))
-      addSlotToContainer(new StaticComponentSlot(this, otherInventory, index, x, y, api.driver.Slot.None, Tier.Any) {
+    }
+  }
+  for (i <- 16 until 64) {
+    addSlotToContainer(new InventorySlot(this, otherInventory, inventorySlots.size, -10000, -10000))
+  }
+
+  addPlayerInventorySlots(6, 160)
+
+  private var lastSentBuffer = -1
+
+  @SideOnly(Side.CLIENT)
+  override def updateProgressBar(id: Int, value: Int) {
+    super.updateProgressBar(id, value)
+    if (id == 0) {
+      robot.globalBuffer = value
+    }
+  }
+
+  override def detectAndSendChanges() {
+    super.detectAndSendChanges()
+    if (FMLCommonHandler.instance.getEffectiveSide.isServer) {
+      val currentBuffer = robot.globalBuffer.toInt
+      if (currentBuffer != lastSentBuffer) {
+        lastSentBuffer = currentBuffer
+        sendProgressBarUpdate(0, lastSentBuffer)
+      }
+    }
+  }
+
+  override def canInteractWith(player: EntityPlayer) =
+    super.canInteractWith(player) && robot.canInteract(player.getCommandSenderName)
+
+  class InventorySlot(container: Player, inventory: IInventory, index: Int, x: Int, y: Int) extends StaticComponentSlot(container, inventory, index, x, y, api.driver.Slot.None, Tier.Any) {
     def isValid = robot.isInventorySlot(getSlotIndex)
 
     @SideOnly(Side.CLIENT)
@@ -35,24 +67,5 @@ class Robot(playerInventory: InventoryPlayer, robot: tileentity.Robot) extends P
       if (isValid) super.getStack
       else null
     }
-      })
   }
 }
-
-  addPlayerInventorySlots(6, 160)
-
-  var lastSentBuffer = Double.NegativeInfinity
-
-  override def detectAndSendChanges() {
-    super.detectAndSendChanges()
-    if (FMLCommonHandler.instance.getEffectiveSide.isServer) {
-      if (math.abs(robot.globalBuffer - lastSentBuffer) > 1) {
-        lastSentBuffer = robot.globalBuffer
-        ServerPacketSender.sendPowerState(robot)
-      }
-    }
-  }
-
-  override def canInteractWith(player: EntityPlayer) =
-    super.canInteractWith(player) && robot.canInteract(player.getCommandSenderName)
-}

src/main/scala/li/cil/oc/common/container/RobotAssembler.scala

@@ -5,8 +5,7 @@ import cpw.mods.fml.common.FMLCommonHandler
 import li.cil.oc.common.{InventorySlots, tileentity}
 import li.cil.oc.util.ItemUtils
 import net.minecraft.entity.player.InventoryPlayer
-import net.minecraft.inventory.{ICrafting, Slot}
+import net.minecraft.inventory.Slot
-import scala.collection.convert.WrapAsScala._
 import li.cil.oc.api
 import li.cil.oc.common.InventorySlots.Tier
 import li.cil.oc.client.gui.Icons
@@ -84,11 +83,4 @@ class RobotAssembler(playerInventory: InventoryPlayer, assembler: tileentity.Rob
       }
     }
   }
-
-  private def sendProgressBarUpdate(id: Int, value: Int) {
-    for (entry <- crafters) entry match {
-      case player: ICrafting => player.sendProgressBarUpdate(this, id, value)
-      case _ =>
-    }
-  }
 }

src/main/scala/li/cil/oc/common/tileentity/Robot.scala

@@ -44,7 +44,7 @@ class Robot(val isRemote: Boolean) extends traits.Computer with traits.PowerInfo
 
   // ----------------------------------------------------------------------- //
 
-  val actualInventorySize = 275
+  val actualInventorySize = 83
 
   var inventorySize = 0
 
@@ -547,7 +547,7 @@ class Robot(val isRemote: Boolean) extends traits.Computer with traits.PowerInfo
 
   override def hasRedstoneCard = (containerSlots ++ componentSlots).exists(slot => Option(getStackInSlot(slot)).fold(false)(driver.item.RedstoneCard.worksWith))
 
-  private def computeInventorySize() = math.min(256, (containerSlots ++ componentSlots).foldLeft(0)((acc, slot) => acc + (Option(getStackInSlot(slot)) match {
+  private def computeInventorySize() = math.min(64, (containerSlots ++ componentSlots).foldLeft(0)((acc, slot) => acc + (Option(getStackInSlot(slot)) match {
     case Some(stack) => Option(Driver.driverFor(stack)) match {
       case Some(driver: api.driver.Inventory) => driver.inventoryCapacity(stack)
       case _ => 0

src/main/scala/li/cil/oc/server/driver/item/Loot.scala

@@ -8,7 +8,7 @@ import net.minecraft.item.ItemStack
 import net.minecraftforge.common.DimensionManager
 
 object Loot extends Item {
-  override def worksWith(stack: ItemStack) = isOneOf(stack, api.Items.get("lootDisk"))
+  override def worksWith(stack: ItemStack) = isOneOf(stack, api.Items.get("lootDisk"), api.Items.get("openOS"))
 
   override def createEnvironment(stack: ItemStack, container: component.Container) =
     createEnvironment(stack, 0, container)