What am I even doing.

src/main/scala/li/cil/oc/OpenComputers.scala

@@ -19,7 +19,7 @@ object OpenComputers {
 
   final val Name = "OpenComputers"
 
-  final val Version = "1.5.15"
+  final val Version = "@VERSION@"
 
   var log = LogManager.getLogger(Name)
 

src/main/scala/li/cil/oc/client/renderer/block/ServerRack.scala

@@ -7,7 +7,7 @@ import net.minecraft.client.renderer.RenderBlocks
 import net.minecraftforge.common.util.ForgeDirection
 
 object ServerRack {
-  def render(rack: tileentity.ServerRack, x: Int, y: Int, z: Int, block: Block, renderer: RenderBlocks): Unit = {
+  def render(rack: tileentity.Rack, x: Int, y: Int, z: Int, block: Block, renderer: RenderBlocks): Unit = {
     val previousRenderAllFaces = renderer.renderAllFaces
     val u1 = 1 / 16f
     val u2 = 15 / 16f
@@ -26,7 +26,7 @@ object ServerRack {
     val front = rack.facing
     def renderSide(side: ForgeDirection, lx: Double, lz: Double, hx: Double, hz: Double) {
       if (side == front) {
-        for (i <- 0 until 4 if rack.isPresent(i).isDefined) {
+        for (i <- 0 until 4 if rack.getStackInSlot(i) != null) {
           side match {
             case ForgeDirection.WEST =>
               renderer.setRenderBounds(lx, v2 - (i + 1) * fs, lz + u1, u2, v2 - i * fs, hz - u1)

src/main/scala/li/cil/oc/common/EventHandler.scala

@@ -365,12 +365,13 @@ object EventHandler {
           case _ => // Dafuq?
         }
         case rack: ServerRack =>
-          (0 until rack.getSizeInventory).
+          // TODO
-            map(rack.getMountable).
+//          (0 until rack.getSizeInventory).
-            filter(_ != null).
+//            map(rack.getMountable).
-            map(_.machine()).
+//            filter(_ != null).
-            filter(_ != null).
+//            map(_.machine()).
-            foreach(_.stop())
+//            filter(_ != null).
+//            foreach(_.stop())
       })
     }
   }

src/main/scala/li/cil/oc/common/block/ServerRack.scala

@@ -52,5 +52,5 @@ class ServerRack extends RedstoneAware with traits.SpecialBlock with traits.Powe
 
   override def hasTileEntity(metadata: Int) = true
 
-  override def createTileEntity(world: World, metadata: Int) = new tileentity.ServerRack()
+  override def createTileEntity(world: World, metadata: Int) = new tileentity.Rack()
 }

src/main/scala/li/cil/oc/common/inventory/InventoryProxy.scala

@@ -0,0 +1,35 @@
+package li.cil.oc.common.inventory
+
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.inventory.IInventory
+import net.minecraft.item.ItemStack
+
+trait InventoryProxy extends IInventory {
+  def proxiedInventory: IInventory
+
+  override def getSizeInventory = proxiedInventory.getSizeInventory
+
+  override def getInventoryStackLimit = proxiedInventory.getInventoryStackLimit
+
+  override def hasCustomInventoryName = proxiedInventory.hasCustomInventoryName
+
+  override def getInventoryName = proxiedInventory.getInventoryName
+
+  override def markDirty() = proxiedInventory.markDirty()
+
+  override def getStackInSlot(slot: Int) = proxiedInventory.getStackInSlot(slot)
+
+  override def setInventorySlotContents(slot: Int, stack: ItemStack) = proxiedInventory.setInventorySlotContents(slot, stack)
+
+  override def decrStackSize(slot: Int, amount: Int) = proxiedInventory.decrStackSize(slot, amount)
+
+  override def openInventory() = proxiedInventory.openInventory()
+
+  override def closeInventory() = proxiedInventory.closeInventory()
+
+  override def getStackInSlotOnClosing(slot: Int) = proxiedInventory.getStackInSlotOnClosing(slot)
+
+  override def isItemValidForSlot(slot: Int, stack: ItemStack) = proxiedInventory.isItemValidForSlot(slot, stack)
+
+  override def isUseableByPlayer(player: EntityPlayer) = proxiedInventory.isUseableByPlayer(player)
+}

src/main/scala/li/cil/oc/common/item/Terminal.scala

@@ -73,7 +73,7 @@ class Terminal(val parent: Delegator) extends traits.Delegate {
                 }
                 keys += key
                 terminal.connect(server.machine.node)
-                ServerPacketSender.sendServerState(rack, slot)
+//                ServerPacketSender.sendServerState(rack, slot)
                 stack.getTagCompound.setString(Settings.namespace + "key", key)
                 stack.getTagCompound.setString(Settings.namespace + "server", server.machine.node.address)
                 player.inventory.markDirty()

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

@@ -61,7 +61,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
   // ----------------------------------------------------------------------- //
   // AbstractBusAware
 
-  override def installedComponents: Iterable[ManagedEnvironment] = ???
+  override def installedComponents: Iterable[ManagedEnvironment] = Iterable.empty // TODO
 
   @Method(modid = Mods.IDs.StargateTech2)
   override def getInterfaces(side: Int) = if (side != facing.ordinal) {
@@ -125,7 +125,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
     if (isServer) {
       isOutputEnabled = hasRedstoneCard
       isAbstractBusAvailable = hasAbstractBusCard
-      //      ServerPacketSender.sendServerPresence(this) TODO
+      ServerPacketSender.sendServerPresence(this)
     }
     else {
       world.markBlockForUpdate(x, y, z)
@@ -142,7 +142,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
       components.zipWithIndex.collect {
         case (Some(mountable: RackMountable), slot) if isWorking(mountable) != lastWorking(slot) =>
           lastWorking(slot) = isWorking(mountable)
-//          ServerPacketSender.sendServerState(this, slot) TODO
+          ServerPacketSender.sendServerState(this, slot)
           world.notifyBlocksOfNeighborChange(x, y, z, block)
           // These are working state dependent, so recompute them.
           isOutputEnabled = hasRedstoneCard
@@ -157,11 +157,11 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
 
   def stacksForSide(side: ForgeDirection): IndexedSeq[ItemStack] =
     if (side == facing) new Array[ItemStack](4)
-    else nodeMapping(toLocal(side.ordinal)).map(info => getStackInSlot(info._1))
+    else nodeMapping(toLocal(side).ordinal).map(info => getStackInSlot(info._1))
 
   def nodesForSide(side: ForgeDirection): IndexedSeq[Node] =
     if (side == facing) new Array[Node](4)
-    else nodeMapping(toLocal(side.ordinal)).map {
+    else nodeMapping(toLocal(side).ordinal).map {
       case (slot, nodeNum) => (components(slot), nodeNum)
     }.collect {
       case (Some(mountable: RackMountable), nodeNum) => mountable.getNodeAt(nodeNum)

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

@@ -110,14 +110,14 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
   def markForSaving() = markChunkDirty = true
 
   override def installedComponents = servers.flatMap {
-    case Some(server) => server.inventory.components collect {
+    case Some(server) => server.components collect {
       case Some(component) => component
     }
     case _ => Iterable.empty
   }
 
   def hasAbstractBusCard = servers exists {
-    case Some(server) => server.machine.isRunning && server.inventory.items.exists {
+    case Some(server) => server.machine.isRunning && server.items.exists {
       case Some(stack) => DriverAbstractBusCard.worksWith(stack, server.getClass)
       case _ => false
     }
@@ -125,7 +125,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
   }
 
   def hasRedstoneCard = servers exists {
-    case Some(server) => server.machine.isRunning && server.inventory.items.exists {
+    case Some(server) => server.machine.isRunning && server.items.exists {
       case Some(stack) => DriverRedstoneCard.worksWith(stack, server.getClass)
       case _ => false
     }
@@ -280,7 +280,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
         val isRunning = servers(i).fold(false)(_.machine.isRunning)
         if (_isRunning(i) != isRunning) {
           _isRunning(i) = isRunning
-          ServerPacketSender.sendServerState(this, i)
+//          ServerPacketSender.sendServerState(this, i)
           world.notifyBlocksOfNeighborChange(x, y, z, block)
         }
       }
@@ -289,7 +289,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
 
       servers collect {
         case Some(server) =>
-          server.inventory.updateComponents()
+          server.updateComponents()
           terminals(server.slot).buffer.update()
       }
     }
@@ -320,8 +320,8 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
     super.readFromNBTForServer(nbt)
     for (slot <- 0 until getSizeInventory) {
       if (getStackInSlot(slot) != null) {
-        val server = new component.Server(this, slot)
+//        val server = new component.Server(this, slot)
-        servers(slot) = Option(server)
+//        servers(slot) = Option(server)
       }
     }
     nbt.getTagList(Settings.namespace + "servers", NBT.TAG_COMPOUND).toArray[NBTTagCompound].
@@ -456,11 +456,11 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
   override protected def onItemAdded(slot: Int, stack: ItemStack) {
     super.onItemAdded(slot, stack)
     if (isServer) {
-      val server = new component.Server(this, slot)
+//      val server = new component.Server(this, slot)
-      servers(slot) = Some(server)
+//      servers(slot) = Some(server)
-      reconnectServer(slot, server)
+//      reconnectServer(slot, server)
-      Network.joinNewNetwork(server.machine.node)
+//      Network.joinNewNetwork(server.machine.node)
-      terminals(slot).connect(server.machine.node)
+//      terminals(slot).connect(server.machine.node)
     }
   }
 
@@ -470,9 +470,9 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
       servers(slot) match {
         case Some(server) =>
           server.machine.node.remove()
-          server.inventory.containerOverride = stack
+//          server.containerOverride = stack
-          server.inventory.save(new NBTTagCompound()) // Only flush components.
+          server.save(new NBTTagCompound()) // Only flush components.
-          server.inventory.markDirty()
+          server.markDirty()
         case _ =>
       }
       servers(slot) = None
@@ -485,7 +485,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
     if (isServer) {
       isOutputEnabled = hasRedstoneCard
       isAbstractBusAvailable = hasAbstractBusCard
-      ServerPacketSender.sendServerPresence(this)
+//      ServerPacketSender.sendServerPresence(this)
     }
     else {
       world.markBlockForUpdate(x, y, z)

src/main/scala/li/cil/oc/integration/opencomputers/DriverServer.scala

@@ -7,6 +7,7 @@ import li.cil.oc.api.network.ManagedEnvironment
 import li.cil.oc.common.Slot
 import li.cil.oc.common.tileentity
 import li.cil.oc.server.component
+import li.cil.oc.util.ExtendedInventory._
 import net.minecraft.item.ItemStack
 
 object DriverServer extends Item {
@@ -17,7 +18,7 @@ object DriverServer extends Item {
     api.Items.get(Constants.ItemName.ServerCreative))
 
   override def createEnvironment(stack: ItemStack, host: EnvironmentHost): ManagedEnvironment = host match {
-    case rack: tileentity.ServerRack => new component.Server(rack, ???)
+    case rack: tileentity.Rack => new component.Server(rack, rack.indexOf(stack))
     case _ => null // Welp.
   }
 

src/main/scala/li/cil/oc/server/PacketHandler.scala

@@ -225,7 +225,7 @@ object PacketHandler extends CommonPacketHandler {
       case Some(rack) => p.player match {
         case player: EntityPlayerMP if rack.isUseableByPlayer(player) =>
           rack.range = math.min(math.max(0, p.readInt()), Settings.get.maxWirelessRange).toInt
-          PacketSender.sendServerState(rack)
+//          PacketSender.sendServerState(rack)
         case _ =>
       }
       case _ => // Invalid packet.
@@ -243,9 +243,9 @@ object PacketHandler extends CommonPacketHandler {
               case Some(server) => rack.reconnectServer(number, server)
               case _ =>
             }
-            PacketSender.sendServerState(rack, number)
+//            PacketSender.sendServerState(rack, number)
           }
-          else PacketSender.sendServerState(rack, number, Some(player))
+//          else PacketSender.sendServerState(rack, number, Some(player))
         case _ =>
       }
       case _ => // Invalid packet.

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

@@ -2,7 +2,9 @@ package li.cil.oc.server
 
 import li.cil.oc.api.component.TextBuffer.ColorDepth
 import li.cil.oc.api.driver.EnvironmentHost
+import li.cil.oc.api.driver.item.RackMountable
 import li.cil.oc.api.event.FileSystemAccessEvent
+import li.cil.oc.api.internal.StateAware
 import li.cil.oc.api.network.Node
 import li.cil.oc.common._
 import li.cil.oc.common.tileentity.Waypoint
@@ -548,14 +550,14 @@ object PacketSender {
     pb.sendToPlayersNearTileEntity(t)
   }
 
-  def sendServerPresence(t: tileentity.ServerRack) {
+  def sendServerPresence(t: tileentity.Rack) {
     val pb = new SimplePacketBuilder(PacketType.ServerPresence)
 
     pb.writeTileEntity(t)
-    t.servers.foreach {
+    t.components.foreach {
-      case Some(server) =>
+      case Some(mountable: RackMountable) =>
         pb.writeBoolean(true)
-        pb.writeUTF(server.machine.node.address)
+        pb.writeUTF(mountable.node.address)
       case _ =>
         pb.writeBoolean(false)
     }
@@ -563,28 +565,31 @@ object PacketSender {
     pb.sendToPlayersNearTileEntity(t)
   }
 
-  def sendServerState(t: tileentity.ServerRack) {
+  def sendServerState(t: tileentity.Rack) {
     val pb = new SimplePacketBuilder(PacketType.ComputerState)
 
     pb.writeTileEntity(t)
     pb.writeInt(-1)
-    pb.writeInt(t.range)
+//    pb.writeInt(t.range) TODO
 
     pb.sendToPlayersNearTileEntity(t)
   }
 
-  def sendServerState(t: tileentity.ServerRack, number: Int, player: Option[EntityPlayerMP] = None) {
+  def sendServerState(t: tileentity.Rack, number: Int, player: Option[EntityPlayerMP] = None) {
     val pb = new SimplePacketBuilder(PacketType.ComputerState)
 
     pb.writeTileEntity(t)
     pb.writeInt(number)
-    pb.writeBoolean(t.isRunning(number))
+    pb.writeBoolean(t.components(number) match {
-    pb.writeDirection(t.sides(number))
+      case Some(mountable: RackMountable) => mountable.getCurrentState.contains(StateAware.State.IsWorking)
-    val keys = t.terminals(number).keys
+      case _ => false
-    pb.writeInt(keys.length)
+    })
-    for (key <- keys) {
+//    pb.writeDirection(t.sides(number)) TODO
-      pb.writeUTF(key)
+//    val keys = t.terminals(number).keys
-    }
+//    pb.writeInt(keys.length)
+//    for (key <- keys) {
+//      pb.writeUTF(key)
+//    }
 
     player match {
       case Some(p) => pb.sendToPlayer(p)

src/main/scala/li/cil/oc/server/component/Server.scala

@@ -25,100 +25,17 @@ import net.minecraft.nbt.NBTTagCompound
 
 import scala.collection.convert.WrapAsJava._
 
-class Server(val rack: tileentity.ServerRack, val slot: Int) extends Environment with driver.item.RackMountable with MachineHost with internal.Server {
+class Server(val rack: tileentity.Rack, val slot: Int) extends Environment with MachineHost with ServerInventory with ComponentInventory with driver.item.RackMountable with internal.Server {
   val machine = Machine.create(this)
 
-  val inventory = new NetworkedInventory()
-
   // Used to grab messages when not connected to any side in the server rack.
   val node = api.Network.newNode(this, Visibility.Network).create()
 
-  machine.onHostChanged()
+  machine.onHostChanged() // TODO ???
-
-  def tier = Delegator.subItem(rack.getStackInSlot(slot)) match {
-    case Some(server: item.Server) => server.tier
-    case _ => 0
-  }
 
   // ----------------------------------------------------------------------- //
+  // Environment
 
-  override def getCurrentState: util.EnumSet[State] = ???
-
-  override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float): Array[Node] = ???
-
-  override def getNodeCount: Int = ???
-
-  override def getNodeAt(index: Int): Node = ???
-
-  override def update(): Unit = ???
-
-  override def canUpdate: Boolean = ???
-
-  override def onActivate(player: EntityPlayer): Unit = ???
-
-  // ----------------------------------------------------------------------- //
-
-  override def internalComponents(): Iterable[ItemStack] = (0 until inventory.getSizeInventory).collect {
-    case i if inventory.getStackInSlot(i) != null && inventory.isComponentSlot(i, inventory.getStackInSlot(i)) => inventory.getStackInSlot(i)
-  }
-
-  override def componentSlot(address: String) = inventory.components.indexWhere(_.exists(env => env.node != null && env.node.address == address))
-
-  override def xPosition = rack.x + 0.5
-
-  override def yPosition = rack.y + 0.5
-
-  override def zPosition = rack.z + 0.5
-
-  override def world = rack.world
-
-  override def markChanged() = rack.markChanged()
-
-  // ----------------------------------------------------------------------- //
-
-  override def onConnect(node: Node) {}
-
-  override def onDisconnect(node: Node) {}
-
-  override def onMessage(message: Message) {
-    // If we're internal mode and this server is not connected to any side, we
-    // must manually propagate network messages to other servers in the rack.
-    // Ensure the message originated in our local network, to avoid infinite
-    // recursion if two unconnected servers are in one server rack.
-    if (rack.internalSwitch && message.name == "network.message" &&
-      rack.sides(this.slot).isEmpty && // Only if we're in internal mode.
-      message.source != machine.node && // In this case it was relayed from another internal machine.
-      node.network.node(message.source.address) != null) {
-      for (slot <- rack.servers.indices) {
-        rack.servers(slot) match {
-          case Some(server) if server != this => server.machine.node.sendToNeighbors(message.name, message.data: _*)
-          case _ =>
-        }
-      }
-    }
-  }
-
-  override def onMachineConnect(node: Node) {
-    if (node == machine.node) {
-      node.connect(this.node)
-    }
-    inventory.onConnect(node)
-  }
-
-  override def onMachineDisconnect(node: Node) = inventory.onDisconnect(node)
-
-  def load(nbt: NBTTagCompound) {
-    machine.load(nbt.getCompoundTag("machine"))
-  }
-
-  def save(nbt: NBTTagCompound) {
-    nbt.setNewCompoundTag("machine", machine.save)
-    inventory.saveComponents()
-    inventory.markDirty()
-  }
-
-  // Required due to abstract overrides in component inventory.
-  class NetworkedInventory extends ServerInventory with ComponentInventory {
   override def onConnect(node: Node) {
     if (node == this.node) {
       connectComponents()
@@ -131,20 +48,116 @@ class Server(val rack: tileentity.ServerRack, val slot: Int) extends Environment
     }
   }
 
-    override def tier = Server.this.tier
+  override def onMessage(message: Message) {
+    // If we're internal mode and this server is not connected to any side, we
+    // must manually propagate network messages to other servers in the rack.
+    // Ensure the message originated in our local network, to avoid infinite
+    // recursion if two unconnected servers are in one server rack.
+    //    if (rack.internalSwitch && message.name == "network.message" &&
+    //      rack.sides(this.slot).isEmpty && // Only if we're in internal mode.
+    //      message.source != machine.node && // In this case it was relayed from another internal machine.
+    //      node.network.node(message.source.address) != null) {
+    //      for (slot <- rack.servers.indices) {
+    //        rack.servers(slot) match {
+    //          case Some(server) if server != this => server.machine.node.sendToNeighbors(message.name, message.data: _*)
+    //          case _ =>
+    //        }
+    //      }
+    //    }
+  }
 
-    var containerOverride: ItemStack = _
+  override def load(nbt: NBTTagCompound) {
+    super.load(nbt)
+    machine.load(nbt.getCompoundTag("machine"))
+  }
 
-    override def container = if (containerOverride != null) containerOverride else rack.getStackInSlot(slot)
+  override def save(nbt: NBTTagCompound) {
+    super.save(nbt)
+    nbt.setNewCompoundTag("machine", machine.save)
+  }
 
-    override def node() = machine.node
+  // ----------------------------------------------------------------------- //
+  // MachineHost
 
-    override def onMessage(message: Message) {}
+  override def internalComponents(): Iterable[ItemStack] = (0 until getSizeInventory).collect {
+    case i if getStackInSlot(i) != null && isComponentSlot(i, getStackInSlot(i)) => getStackInSlot(i)
+  }
+
+  override def componentSlot(address: String) = components.indexWhere(_.exists(env => env.node != null && env.node.address == address))
+
+  override def onMachineConnect(node: Node) {
+    if (node == machine.node) {
+      node.connect(this.node)
+    }
+    onConnect(node)
+  }
+
+  override def onMachineDisconnect(node: Node) = onDisconnect(node)
+
+  // ----------------------------------------------------------------------- //
+  // EnvironmentHost
+
+  override def xPosition = rack.x + 0.5
+
+  override def yPosition = rack.y + 0.5
+
+  override def zPosition = rack.z + 0.5
+
+  override def world = rack.world
+
+  override def markChanged() = rack.markChanged()
+
+  // ----------------------------------------------------------------------- //
+  // ServerInventory
+
+  override def tier = Delegator.subItem(container) match {
+    case Some(server: item.Server) => server.tier
+    case _ => 0
+  }
+
+  // ----------------------------------------------------------------------- //
+  // ItemStackInventory
 
   override def host = rack
 
-    // Resolves conflict between ComponentInventory and ServerInventory.
+  // ----------------------------------------------------------------------- //
-    override def getInventoryStackLimit = 1
+  // ComponentInventory
+
+  override def container = rack.getStackInSlot(slot)
+
+  override protected def connectItemNode(node: Node) {
+    if (machine.node != null && node != null) {
+      api.Network.joinNewNetwork(machine.node)
+      machine.node.connect(node)
+    }
   }
 
+  // ----------------------------------------------------------------------- //
+  // RackMountable
+
+  override def getNodeCount: Int = ???
+
+  override def getNodeAt(index: Int): Node = ???
+
+  override def onActivate(player: EntityPlayer): Unit = ???
+
+  // ----------------------------------------------------------------------- //
+  // ManagedEnvironment
+
+  override def canUpdate: Boolean = ???
+
+  override def update(): Unit = ???
+
+  // ----------------------------------------------------------------------- //
+  // StateAware
+
+  override def getCurrentState: util.EnumSet[State] = {
+    if (machine.isRunning) util.EnumSet.of(internal.StateAware.State.IsWorking)
+    else util.EnumSet.noneOf(classOf[internal.StateAware.State])
+  }
+
+  // ----------------------------------------------------------------------- //
+  // Analyzable
+
+  override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = Array(machine.node)
 }

src/main/scala/li/cil/oc/util/ExtendedInventory.scala

@@ -3,14 +3,19 @@ package li.cil.oc.util
 import net.minecraft.inventory.IInventory
 import net.minecraft.item.ItemStack
 
+import scala.collection.mutable
 import scala.language.implicitConversions
 
 object ExtendedInventory {
 
   implicit def extendedInventory(inventory: IInventory): ExtendedInventory = new ExtendedInventory(inventory)
 
-  class ExtendedInventory(val inventory: IInventory) extends Iterable[ItemStack] {
+  class ExtendedInventory(val inventory: IInventory) extends mutable.IndexedSeq[ItemStack] {
-    override def iterator: Iterator[ItemStack] = (for (stack <- (0 until inventory.getSizeInventory).map(inventory.getStackInSlot)) yield stack).iterator
+    override def length = inventory.getSizeInventory
+
+    override def update(idx: Int, elem: ItemStack) = inventory.setInventorySlotContents(idx, elem)
+
+    override def apply(idx: Int) = inventory.getStackInSlot(idx)
   }
 
 }