made power distributor logic a component to be re-usable in robots; general shuffling for robot stuff, now building an "internal" network for each robot that is *not* connected to the outside world. this will limit some cards installed in the robot (e.g. gpus won't work with external screens) but makes it much easier to re-use components without having the issue that they interfere with external stuff (also, it makes robots less of a complete replacement for normal computers, which they should not be, they have a very specific role, after all); reworked how stuff gets saved a bit more, nodes are now generally saved by their host - in particular the base tile entity we use (Environment) will now only automatically save its node if it is that node's host

li/cil/oc/api/driver/Slot.java

@@ -7,6 +7,11 @@ package li.cil.oc.api.driver;
  * a computer's inventory.
  */
 public enum Slot {
+    /**
+     * Invalid slot type.
+     */
+    None,
+
     /**
      * Extension cards such as graphics cards or redstone cards.
      */

li/cil/oc/client/PacketHandler.scala

@@ -63,8 +63,8 @@ class PacketHandler extends CommonPacketHandler {
     }
 
   def onPowerStateResponse(p: PacketParser) =
-    p.readTileEntity[PowerDistributor]() match {
+    p.readTileEntity[PowerInformation]() match {
-      case Some(t) => t.average = p.readDouble()
+      case Some(t) => t.globalPower = p.readDouble()
       case _ => // Invalid packet.
     }
 

li/cil/oc/client/renderer/tileentity/CableRenderer.scala

@@ -132,7 +132,6 @@ object CableRenderer extends TileEntitySpecialRenderer {
 
     GL11.glPushMatrix()
     GL11.glTranslated(x, y, z)
-    GL11.glColor3f(1, 1, 1)
 
     bindTexture(texture)
     GL11.glCallList(displayLists + cable.neighbors)

li/cil/oc/client/renderer/tileentity/PowerDistributorRenderer.scala

@@ -13,13 +13,13 @@ object PowerDistributorRenderer extends TileEntitySpecialRenderer {
   private val sideOn = new ResourceLocation(Config.resourceDomain, "textures/blocks/power_distributor_on.png")
 
   override def renderTileEntityAt(tileEntity: TileEntity, x: Double, y: Double, z: Double, f: Float) = {
-    val balancer = tileEntity.asInstanceOf[tileentity.PowerDistributor]
+    val distributor = tileEntity.asInstanceOf[tileentity.PowerDistributor]
-    if (balancer.average > 0) {
+    if (distributor.globalPower > 0) {
       GL11.glPushAttrib(0xFFFFFF)
 
       RenderState.disableLighting()
       RenderState.makeItBlend()
-      RenderState.setBlendAlpha(balancer.average.toFloat)
+      RenderState.setBlendAlpha(distributor.globalPower.toFloat)
 
       GL11.glPushMatrix()
 

li/cil/oc/common/component/Buffer.scala

@@ -4,6 +4,7 @@ import li.cil.oc.api.network.{Message, Node, Visibility}
 import li.cil.oc.common.component
 import li.cil.oc.common.tileentity
 import li.cil.oc.server.{PacketSender => ServerPacketSender}
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.{Persistable, PackedColor, TextBuffer}
 import li.cil.oc.{api, Config}
 import net.minecraft.nbt.NBTTagCompound
@@ -115,7 +116,8 @@ class Buffer(val owner: Buffer.Environment) extends api.network.Environment with
   // ----------------------------------------------------------------------- //
 
   override def load(nbt: NBTTagCompound) = {
-    buffer.load(nbt.getCompoundTag(Config.namespace + "buffer"))
+    node.load(nbt.getCompoundTag("node"))
+    buffer.load(nbt.getCompoundTag("buffer"))
   }
 
   override def save(nbt: NBTTagCompound) = {
@@ -135,9 +137,8 @@ class Buffer(val owner: Buffer.Environment) extends api.network.Environment with
       }
     }
 
-    val screenNbt = new NBTTagCompound
+    nbt.setNewCompoundTag("node", node.save)
-    buffer.save(screenNbt)
+    nbt.setNewCompoundTag("buffer", buffer.save)
-    nbt.setCompoundTag(Config.namespace + "buffer", screenNbt)
   }
 }
 
@@ -164,22 +165,6 @@ object Buffer {
 
     // ----------------------------------------------------------------------- //
 
-    override def onConnect(node: Node) {
-      super.onConnect(node)
-      if (node == this.node) {
-        node.connect(buffer.node)
-      }
-    }
-
-    override def onDisconnect(node: Node) {
-      super.onDisconnect(node)
-      if (node == this.node) {
-        buffer.node.remove()
-      }
-    }
-
-    // ----------------------------------------------------------------------- //
-
     def onScreenColorChange(foreground: Int, background: Int) {
       if (isServer) {
         world.markTileEntityChunkModified(x, y, z, this.asInstanceOf[net.minecraft.tileentity.TileEntity])

li/cil/oc/common/container/Case.scala

@@ -1,52 +1,22 @@
 package li.cil.oc.common.container
 
 import li.cil.oc.api
-import li.cil.oc.client.gui.Icons
 import li.cil.oc.common.tileentity
 import net.minecraft.entity.player.{EntityPlayer, InventoryPlayer}
-import net.minecraft.inventory.Slot
-import net.minecraft.item.ItemStack
 
 class Case(playerInventory: InventoryPlayer, `case`: tileentity.Case) extends Player(playerInventory, `case`) {
-  addSlotToContainer(new Slot(`case`, getInventory.size, 58, 17) {
+  addSlotToContainer(58, 17, api.driver.Slot.Power)
-    setBackgroundIcon(Icons.get(api.driver.Slot.Power))
-
-    override def isItemValid(item: ItemStack) = {
-      `case`.isItemValidForSlot(0, item)
-    }
-  })
 
   for (i <- 0 to 2) {
-    val index = getInventory.size
+    addSlotToContainer(80, 17 + i * slotSize, api.driver.Slot.Card)
-    addSlotToContainer(new Slot(`case`, index, 80, 17 + i * slotSize) {
-      setBackgroundIcon(Icons.get(api.driver.Slot.Card))
-
-      override def isItemValid(item: ItemStack) = {
-        `case`.isItemValidForSlot(index, item)
-      }
-    })
   }
 
   for (i <- 0 to 1) {
-    val index = getInventory.size
+    addSlotToContainer(102, 17 + i * slotSize, api.driver.Slot.Memory)
-    addSlotToContainer(new Slot(`case`, index, 102, 17 + i * slotSize) {
-      setBackgroundIcon(Icons.get(api.driver.Slot.Memory))
-
-      override def isItemValid(item: ItemStack) = {
-        `case`.isItemValidForSlot(index, item)
-      }
-    })
   }
 
   for (i <- 0 to 1) {
-    val index = getInventory.size
+    addSlotToContainer(124, 17 + i * slotSize, api.driver.Slot.HardDiskDrive)
-    addSlotToContainer(new Slot(`case`, index, 124, 17 + i * slotSize) {
-      setBackgroundIcon(Icons.get(api.driver.Slot.HardDiskDrive))
-
-      override def isItemValid(item: ItemStack) = {
-        `case`.isItemValidForSlot(index, item)
-      }
-    })
   }
 
   // Show the player's inventory.

li/cil/oc/common/container/DiskDrive.scala

@@ -2,17 +2,8 @@ package li.cil.oc.common.container
 
 import li.cil.oc.common.tileentity
 import net.minecraft.entity.player.InventoryPlayer
-import net.minecraft.inventory.Slot
-import net.minecraft.item.ItemStack
 
 class DiskDrive(playerInventory: InventoryPlayer, drive: tileentity.DiskDrive) extends Player(playerInventory, drive) {
-  // Floppy slot.
+  addSlotToContainer(80, 35)
-  addSlotToContainer(new Slot(drive, 0, 80, 35) {
-    override def isItemValid(item: ItemStack) = {
-      drive.isItemValidForSlot(0, item)
-    }
-  })
-
-  // Show the player's inventory.
   addPlayerInventorySlots(8, 84)
 }

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

@@ -1,5 +1,7 @@
 package li.cil.oc.common.container
 
+import li.cil.oc.api
+import li.cil.oc.client.gui.Icons
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.entity.player.InventoryPlayer
 import net.minecraft.inventory.Container
@@ -103,6 +105,17 @@ abstract class Player(protected val playerInventory: InventoryPlayer, val otherI
     somethingChanged
   }
 
+  def addSlotToContainer(x: Int, y: Int, slot: api.driver.Slot = api.driver.Slot.None) {
+    val index = getInventory.size
+    addSlotToContainer(new Slot(otherInventory, index, x, y) {
+      setBackgroundIcon(Icons.get(slot))
+
+      override def isItemValid(item: ItemStack) = {
+        otherInventory.isItemValidForSlot(index, item)
+      }
+    })
+  }
+
   /** Render player inventory at the specified coordinates. */
   protected def addPlayerInventorySlots(left: Int, top: Int) = {
     // Show the inventory proper. Start at plus one to skip hot bar.

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

@@ -1,46 +1,22 @@
 package li.cil.oc.common.container
 
 import li.cil.oc.api
-import li.cil.oc.client.gui.Icons
 import li.cil.oc.common.tileentity
 import net.minecraft.entity.player.{EntityPlayer, InventoryPlayer}
-import net.minecraft.inventory.Slot
-import net.minecraft.item.ItemStack
 
 class Robot(playerInventory: InventoryPlayer, robot: tileentity.Robot) extends Player(playerInventory, robot) {
-  addSlotToContainer(new Slot(robot, getInventory.size, 176, 200) {
+  addSlotToContainer(176 + 0 * slotSize, 200, api.driver.Slot.Tool)
-    setBackgroundIcon(Icons.get(api.driver.Slot.Tool))
+  addSlotToContainer(176 + 1 * slotSize, 200, api.driver.Slot.Card)
-
+  addSlotToContainer(176 + 2 * slotSize, 200, api.driver.Slot.HardDiskDrive)
-    override def isItemValid(item: ItemStack) = {
-      robot.isItemValidForSlot(0, item)
-    }
-  })
-
-  for (i <- 0 to 1) {
-    val index = getInventory.size
-    addSlotToContainer(new Slot(robot, index, 194 + i * slotSize, 200) {
-      setBackgroundIcon(Icons.get(api.driver.Slot.Card))
-
-      override def isItemValid(item: ItemStack) = {
-        robot.isItemValidForSlot(index, item)
-      }
-    })
-  }
 
   for (i <- 0 to 2) {
     val y = 142 + i * slotSize
     for (j <- 0 to 2) {
       val x = 176 + j * slotSize
-      val index = getInventory.size
+      addSlotToContainer(x, y)
-      addSlotToContainer(new Slot(robot, index, x, y) {
-        override def isItemValid(item: ItemStack) = {
-          robot.isItemValidForSlot(index, item)
-        }
-      })
     }
   }
 
-  // Show the player's inventory.
   addPlayerInventorySlots(8, 142)
 
   override def canInteractWith(player: EntityPlayer) =

li/cil/oc/common/tileentity/ComponentInventory.scala

@@ -41,7 +41,7 @@ trait ComponentInventory extends Inventory with network.Environment with Persist
         }
       }
       components collect {
-        case Some(component) => node.connect(component.node)
+        case Some(component) => connectItemNode(component.node)
       }
     }
   }
@@ -81,7 +81,7 @@ trait ComponentInventory extends Inventory with network.Environment with Persist
         case Some(component) =>
           components(slot) = Some(component)
           component.load(driver.nbt(item))
-          node.connect(component.node)
+          connectItemNode(component.node)
         case _ => // No environment (e.g. RAM).
       }
       case _ => // No driver.
@@ -103,4 +103,8 @@ trait ComponentInventory extends Inventory with network.Environment with Persist
       case _ => // Nothing to do.
     }
   }
+
+  protected def connectItemNode(node: Node) {
+    this.node.connect(node)
+  }
 }

li/cil/oc/common/tileentity/Computer.scala

@@ -4,6 +4,7 @@ import li.cil.oc.Config
 import li.cil.oc.api.network._
 import li.cil.oc.client.{PacketSender => ClientPacketSender}
 import li.cil.oc.server.{PacketSender => ServerPacketSender, driver, component}
+import li.cil.oc.util.ExtendedNBT._
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.ForgeDirection
@@ -84,12 +85,16 @@ abstract class Computer(isRemote: Boolean) extends Environment with ComponentInv
 
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
-    if (computer != null) computer.load(nbt)
+    if (isServer) {
+      computer.load(nbt.getCompoundTag(Config.namespace + "computer"))
+    }
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
-    if (computer != null) computer.save(nbt)
+    if (isServer) {
+      nbt.setNewCompoundTag(Config.namespace + "computer", computer.save)
+    }
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/common/tileentity/Environment.scala

@@ -1,6 +1,8 @@
 package li.cil.oc.common.tileentity
 
+import li.cil.oc.Config
 import li.cil.oc.api.{Network, network}
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.Persistable
 import net.minecraft.nbt.NBTTagCompound
 import scala.math.ScalaNumber
@@ -40,13 +42,13 @@ abstract class Environment extends net.minecraft.tileentity.TileEntity with Tile
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
     load(nbt)
-    if (node != null) node.load(nbt)
+    if (node != null && node.host == this) node.load(nbt.getCompoundTag(Config.namespace + "node"))
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
     save(nbt)
-    if (node != null) node.save(nbt)
+    if (node != null && node.host == this) nbt.setNewCompoundTag(Config.namespace + "node", node.save)
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/common/tileentity/Inventory.scala

@@ -1,12 +1,13 @@
 package li.cil.oc.common.tileentity
 
 import li.cil.oc.Config
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.Persistable
 import net.minecraft.entity.item.EntityItem
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.inventory.IInventory
 import net.minecraft.item.ItemStack
-import net.minecraft.nbt.{NBTTagList, NBTTagCompound}
+import net.minecraft.nbt.NBTTagCompound
 import net.minecraft.world.World
 
 trait Inventory extends TileEntity with IInventory with Persistable {
@@ -82,34 +83,27 @@ trait Inventory extends TileEntity with IInventory with Persistable {
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
 
-    val inventoryNbt = nbt.getTagList(Config.namespace + "inventory.items")
+    nbt.getTagList(Config.namespace + "items").foreach[NBTTagCompound](slotNbt => {
-    for (i <- 0 until inventoryNbt.tagCount) {
-      val slotNbt = inventoryNbt.tagAt(i).asInstanceOf[NBTTagCompound]
       val slot = slotNbt.getByte("slot")
       if (slot >= 0 && slot < items.length) {
-        val item = ItemStack.loadItemStackFromNBT(slotNbt.getCompoundTag("item"))
+        items(slot) = Some(ItemStack.loadItemStackFromNBT(slotNbt.getCompoundTag("item")))
-        items(slot) = Some(item)
       }
-    }
+    })
   }
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
 
-    val inventoryNbt = new NBTTagList()
+    nbt.setNewTagList(Config.namespace + "items",
-    items.zipWithIndex collect {
+      items.zipWithIndex collect {
-      case (Some(stack), slot) => (stack, slot)
+        case (Some(stack), slot) => (stack, slot)
-    } foreach {
+      } map {
-      case (stack, slot) => {
+        case (stack, slot) => {
-        val slotNbt = new NBTTagCompound()
+          val slotNbt = new NBTTagCompound()
-        slotNbt.setByte("slot", slot.toByte)
+          slotNbt.setByte("slot", slot.toByte)
-        val itemNbt = new NBTTagCompound()
+          slotNbt.setNewCompoundTag("item", stack.writeToNBT)
-        stack.writeToNBT(itemNbt)
+        }
-        slotNbt.setCompoundTag("item", itemNbt)
+      })
-        inventoryNbt.appendTag(slotNbt)
-      }
-    }
-    nbt.setTag(Config.namespace + "inventory.items", inventoryNbt)
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/common/tileentity/Keyboard.scala

@@ -1,6 +1,8 @@
 package li.cil.oc.common.tileentity
 
+import li.cil.oc.Config
 import li.cil.oc.server.component
+import li.cil.oc.util.ExtendedNBT._
 import net.minecraft.nbt.NBTTagCompound
 
 class Keyboard(isRemote: Boolean) extends Environment with Rotatable {
@@ -15,14 +17,14 @@ class Keyboard(isRemote: Boolean) extends Environment with Rotatable {
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
     if (isServer) {
-      keyboard.node.load(nbt)
+      keyboard.load(nbt.getCompoundTag(Config.namespace + "keyboard"))
     }
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
     if (isServer) {
-      keyboard.node.save(nbt)
+      nbt.setNewCompoundTag(Config.namespace + "keyboard", keyboard.save)
     }
   }
 }

li/cil/oc/common/tileentity/PowerConverter.scala

@@ -5,6 +5,7 @@ import cpw.mods.fml.common.{Loader, Optional}
 import ic2.api.energy.event.{EnergyTileLoadEvent, EnergyTileUnloadEvent}
 import ic2.api.energy.tile.IEnergySink
 import li.cil.oc.api.network._
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.{Config, api}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.{ForgeDirection, MinecraftForge}
@@ -63,14 +64,14 @@ class PowerConverter extends Environment with IEnergySink with IPowerReceptor wi
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
     if (Loader.isModLoaded("BuildCraft|Energy")) {
-      getPowerProvider.readFromNBT(nbt)
+      getPowerProvider.readFromNBT(nbt.getCompoundTag(Config.namespace + "bc"))
     }
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
     if (Loader.isModLoaded("BuildCraft|Energy")) {
-      getPowerProvider.writeToNBT(nbt)
+      nbt.setNewCompoundTag(Config.namespace + "bc", getPowerProvider.writeToNBT)
     }
   }
 

li/cil/oc/common/tileentity/PowerDistributor.scala

@@ -1,102 +1,44 @@
 package li.cil.oc.common.tileentity
 
+import li.cil.oc.Config
 import li.cil.oc.api.network._
 import li.cil.oc.client.{PacketSender => ClientPacketSender}
-import li.cil.oc.server.network.Connector
+import li.cil.oc.server.component
-import li.cil.oc.server.{PacketSender => ServerPacketSender}
+import li.cil.oc.util.ExtendedNBT._
-import li.cil.oc.{Config, api}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.NBTTagCompound
-import scala.collection.convert.WrapAsScala._
-import scala.collection.mutable
 
-class PowerDistributor extends Environment with Analyzable {
+class PowerDistributor extends Environment with PowerInformation with Analyzable {
-  val node = api.Network.newNode(this, Visibility.Network).
+  val distributor = new component.PowerDistributor(this)
-    withComponent("power", Visibility.Network).
-    create()
 
-  var globalBuffer = 0.0
+  def node = distributor.node
-
-  var globalBufferSize = 0.0
-
-  var average = 0.0
-
-  private var lastSentAverage = 0.0
-
-  private val buffers = mutable.Set.empty[Connector]
-
-  private val distributors = mutable.Set.empty[PowerDistributor]
-
-  private var dirty = true
-
-  // ----------------------------------------------------------------------- //
-
-  @LuaCallback(value = "buffer", direct = true)
-  def buffer(context: Context, args: Arguments): Array[AnyRef] = result(globalBuffer)
-
-  @LuaCallback(value = "bufferSize", direct = true)
-  def bufferSize(context: Context, args: Arguments): Array[AnyRef] = result(globalBufferSize)
 
   // ----------------------------------------------------------------------- //
 
   override def onAnalyze(stats: NBTTagCompound, player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = {
-    stats.setString(Config.namespace + "text.Analyzer.TotalEnergy", "%.2f/%.2f".format(globalBuffer, globalBufferSize))
+    stats.setString(Config.namespace + "text.Analyzer.TotalEnergy", "%.2f/%.2f".format(distributor.globalBuffer, distributor.globalBufferSize))
     this
   }
 
   // ----------------------------------------------------------------------- //
 
-  def changeBuffer(delta: Double): Boolean = {
+  override def readFromNBT(nbt: NBTTagCompound) {
-    if (delta != 0) this.synchronized {
+    super.readFromNBT(nbt)
-      val oldBuffer = globalBuffer
+
-      globalBuffer = (globalBuffer + delta) max 0 min globalBufferSize
+    distributor.load(nbt.getCompoundTag(Config.namespace + "distributor"))
-      if (globalBuffer != oldBuffer) {
+  }
-        dirty = true
+
-        if (delta < 0) {
+  override def writeToNBT(nbt: NBTTagCompound) {
-          var remaining = -delta
+    super.writeToNBT(nbt)
-          for (connector <- buffers) {
+
-            connector.synchronized(if (connector.localBuffer > 0) {
+    nbt.setNewCompoundTag(Config.namespace + "distributor", distributor.save)
-              connector.dirty = true
-              if (connector.localBuffer < remaining) {
-                remaining -= connector.localBuffer
-                connector.localBuffer = 0
-              }
-              else {
-                connector.localBuffer -= remaining
-                return true
-              }
-            })
-          }
-        }
-        else if (delta > 0) {
-          var remaining = delta
-          for (connector <- buffers) {
-            connector.synchronized(if (connector.localBuffer < connector.localBufferSize) {
-              connector.dirty = true
-              val space = connector.localBufferSize - connector.localBuffer
-              if (space < remaining) {
-                remaining -= space
-                connector.localBuffer = connector.localBufferSize
-              }
-              else {
-                connector.localBuffer += remaining
-                return true
-              }
-            })
-          }
-        }
-      }
-    }
-    false
   }
 
   // ----------------------------------------------------------------------- //
 
   override def updateEntity() {
     super.updateEntity()
-    if (isServer && (dirty || buffers.exists(_.dirty))) {
+    distributor.update()
-      updateCachedValues()
-    }
   }
 
   override def validate() {
@@ -105,82 +47,4 @@ class PowerDistributor extends Environment with Analyzable {
       ClientPacketSender.sendPowerStateRequest(this)
     }
   }
-
-  // ----------------------------------------------------------------------- //
-
-  override def onConnect(node: Node) {
-    super.onConnect(node)
-    if (node == this.node) {
-      for (node <- node.network.nodes) node match {
-        case connector: Connector if connector.localBufferSize > 0 => this.synchronized {
-          buffers += connector
-          globalBuffer += connector.localBuffer
-          globalBufferSize += connector.localBufferSize
-        }
-        case _ => node.host match {
-          case distributor: PowerDistributor => distributors += distributor
-          case _ =>
-        }
-      }
-      dirty = true
-    }
-    else node match {
-      case connector: Connector => this.synchronized {
-        buffers += connector
-        globalBuffer += connector.localBuffer
-        globalBufferSize += connector.localBufferSize
-        dirty = true
-      }
-      case _ => node.host match {
-        case distributor: PowerDistributor => distributors += distributor
-        case _ =>
-      }
-    }
-  }
-
-  override def onDisconnect(node: Node) {
-    super.onDisconnect(node)
-    if (node == this.node) this.synchronized {
-      buffers.clear()
-      distributors.clear()
-      globalBuffer = 0
-      globalBufferSize = 0
-      average = -1
-    }
-    else node match {
-      case connector: Connector => this.synchronized {
-        buffers -= connector
-        globalBuffer -= connector.localBuffer
-        globalBufferSize -= connector.localBufferSize
-        dirty = true
-      }
-      case _ => node.host match {
-        case distributor: PowerDistributor => distributors -= distributor
-        case _ =>
-      }
-    }
-  }
-
-  // ----------------------------------------------------------------------- //
-
-  def updateCachedValues() {
-    // Computer average fill ratio of all buffers.
-    val (sumBuffer, sumBufferSize) =
-      buffers.foldRight((0.0, 0.0))((c, acc) => {
-        c.dirty = false // clear dirty flag for all connectors
-        (acc._1 + c.localBuffer, acc._2 + c.localBufferSize)
-      })
-    average = if (globalBufferSize > 0) globalBuffer / globalBufferSize else 0
-    val shouldSend = (lastSentAverage - average).abs > 0.05
-    for (distributor <- distributors) distributor.synchronized {
-      distributor.dirty = false
-      distributor.globalBuffer = sumBuffer
-      distributor.globalBufferSize = sumBufferSize
-      distributor.average = average
-      if (shouldSend) {
-        distributor.lastSentAverage = lastSentAverage
-        ServerPacketSender.sendPowerState(distributor)
-      }
-    }
-  }
 }

li/cil/oc/common/tileentity/PowerInformation.scala

@@ -0,0 +1,5 @@
+package li.cil.oc.common.tileentity
+
+trait PowerInformation extends TileEntity {
+  var globalPower = 0.0
+}

li/cil/oc/common/tileentity/Redstone.scala

@@ -5,9 +5,10 @@ import cpw.mods.fml.common.{Loader, Optional}
 import li.cil.oc.Config
 import li.cil.oc.api.network
 import li.cil.oc.server.{PacketSender => ServerPacketSender}
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.Persistable
 import mods.immibis.redlogic.api.wiring._
-import net.minecraft.nbt.{NBTTagByte, NBTTagList, NBTTagCompound}
+import net.minecraft.nbt.{NBTTagByteArray, NBTTagCompound}
 import net.minecraftforge.common.ForgeDirection
 
 @Optional.InterfaceList(Array(
@@ -104,67 +105,25 @@ with IConnectable with IBundledEmitter with IBundledUpdatable with IRedstoneEmit
   override def load(nbt: NBTTagCompound) = {
     super.load(nbt)
 
-    val inputNbt = nbt.getTagList(Config.namespace + "redstone.input")
+    nbt.getByteArray(Config.namespace + "rs.input").copyToArray(_input)
-    for (i <- 0 until (_input.length min inputNbt.tagCount)) {
+    nbt.getByteArray(Config.namespace + "rs.output").copyToArray(_output)
-      _input(i) = inputNbt.tagAt(i).asInstanceOf[NBTTagByte].data
-    }
 
-    val outputNbt = nbt.getTagList(Config.namespace + "redstone.output")
+    nbt.getTagList(Config.namespace + "rs.bundledInput").iterator[NBTTagByteArray].zipWithIndex.foreach {
-    for (i <- 0 until (_output.length min outputNbt.tagCount)) {
+      case (input, side) => input.byteArray.copyToArray(_bundledInput(side))
-      _output(i) = outputNbt.tagAt(i).asInstanceOf[NBTTagByte].data
     }
-
+    nbt.getTagList(Config.namespace + "rs.bundledOutput").iterator[NBTTagByteArray].zipWithIndex.foreach {
-    val bundledInputNbt = nbt.getTagList(Config.namespace + "redstone.bundledInput")
+      case (input, side) => input.byteArray.copyToArray(_bundledOutput(side))
-    for (i <- 0 until (_bundledInput.length min bundledInputNbt.tagCount)) {
-      val bundleNbt = bundledInputNbt.tagAt(i).asInstanceOf[NBTTagList]
-      for (j <- 0 until (_bundledInput(i).length min bundleNbt.tagCount())) {
-        _bundledInput(i)(j) = bundleNbt.tagAt(j).asInstanceOf[NBTTagByte].data
-      }
-    }
-
-    val bundledOutputNbt = nbt.getTagList(Config.namespace + "redstone.bundledOutput")
-    for (i <- 0 until (_bundledOutput.length min bundledOutputNbt.tagCount)) {
-      val bundleNbt = bundledOutputNbt.tagAt(i).asInstanceOf[NBTTagList]
-      for (j <- 0 until (_bundledOutput(i).length min bundleNbt.tagCount())) {
-        _bundledOutput(i)(j) = bundleNbt.tagAt(j).asInstanceOf[NBTTagByte].data
-      }
     }
   }
 
   override def save(nbt: NBTTagCompound) = {
     super.save(nbt)
 
-    val inputNbt = new NBTTagList()
+    nbt.setByteArray(Config.namespace + "rs.input", _input)
-    for (i <- 0 until _input.length) {
+    nbt.setByteArray(Config.namespace + "rs.output", _output)
-      inputNbt.appendTag(new NBTTagByte(null, _input(i)))
-    }
-    nbt.setTag(Config.namespace + "redstone.input", inputNbt)
 
-    val outputNbt = new NBTTagList()
+    nbt.setNewTagList(Config.namespace + "rs.bundledInput", _bundledInput.view)
-    for (i <- 0 until _output.length) {
+    nbt.setNewTagList(Config.namespace + "rs.bundledOutput", _bundledOutput.view)
-      outputNbt.appendTag(new NBTTagByte(null, _output(i)))
-    }
-    nbt.setTag(Config.namespace + "redstone.output", outputNbt)
-
-    val bundledInputNbt = new NBTTagList()
-    for (i <- 0 until _bundledInput.length) {
-      val bundleNbt = new NBTTagList()
-      for (j <- 0 until _bundledInput(i).length) {
-        bundleNbt.appendTag(new NBTTagByte(null, _bundledInput(i)(j)))
-      }
-      bundledInputNbt.appendTag(bundleNbt)
-    }
-    nbt.setTag(Config.namespace + "redstone.bundledInput", bundledInputNbt)
-
-    val bundledOutputNbt = new NBTTagList()
-    for (i <- 0 until _bundledOutput.length) {
-      val bundleNbt = new NBTTagList()
-      for (j <- 0 until _bundledOutput(i).length) {
-        bundleNbt.appendTag(new NBTTagByte(null, _bundledOutput(i)(j)))
-      }
-      bundledOutputNbt.appendTag(bundleNbt)
-    }
-    nbt.setTag(Config.namespace + "redstone.bundledOutput", bundledOutputNbt)
   }
 
   // ----------------------------------------------------------------------- //

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

@@ -1,30 +1,44 @@
 package li.cil.oc.common.tileentity
 
 import li.cil.oc.Config
+import li.cil.oc.api
 import li.cil.oc.api.driver.Slot
 import li.cil.oc.api.network._
 import li.cil.oc.client.{PacketSender => ClientPacketSender, gui}
 import li.cil.oc.common.component.Buffer
+import li.cil.oc.server
 import li.cil.oc.server.component
 import li.cil.oc.server.component.GraphicsCard
 import li.cil.oc.server.driver.Registry
+import li.cil.oc.util.ExtendedNBT._
 import net.minecraft.client.Minecraft
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
 import scala.Some
 
-class Robot(isRemote: Boolean) extends Computer(isRemote) with Buffer.Environment {
+class Robot(isRemote: Boolean) extends Computer(isRemote) with Buffer.Environment with PowerInformation {
   def this() = this(false)
 
   // ----------------------------------------------------------------------- //
 
-  val gpu = new GraphicsCard.Tier1 {
-    override val maxResolution = (44, 14)
-  }
-  val keyboard = new component.Keyboard(this)
-
   var currentGui: Option[gui.Robot] = None
 
+  override val node = api.Network.newNode(this, Visibility.None).create()
+
+  override val buffer = new Buffer(this) {
+    override def maxResolution = (44, 14)
+  }
+  val (battery, distributor, gpu, keyboard) = if (isServer) {
+    val battery = api.Network.newNode(this, Visibility.Network).withConnector(10000).create()
+    val distributor = new component.PowerDistributor(this)
+    val gpu = new GraphicsCard.Tier1 {
+      override val maxResolution = (44, 14)
+    }
+    val keyboard = new component.Keyboard(this)
+    (battery, distributor, gpu, keyboard)
+  }
+  else (null, null, null, null)
+
   // ----------------------------------------------------------------------- //
 
   def tier = 0
@@ -90,7 +104,11 @@ class Robot(isRemote: Boolean) extends Computer(isRemote) with Buffer.Environmen
 
   override def updateEntity() {
     super.updateEntity()
-    gpu.update()
+    if (isServer) {
+      distributor.changeBuffer(10) // just for testing
+      distributor.update()
+      gpu.update()
+    }
   }
 
   override def validate() {
@@ -110,51 +128,63 @@ class Robot(isRemote: Boolean) extends Computer(isRemote) with Buffer.Environmen
 
   // ----------------------------------------------------------------------- //
 
+  //  override def onMessage(message: Message) {
+  //    if (message.source.network == node.network) {
+  //      computer.node.network.sendToReachable(message.source, message.name, message.data: _*)
+  //    }
+  //    else {
+  //      node.network.sendToReachable(message.source, message.name, message.data: _*)
+  //    }
+  //  }
+
   override def onConnect(node: Node) {
-    super.onConnect(node)
     if (node == this.node) {
-      node.connect(gpu.node)
+      server.network.Network.create(computer.node)
-      node.connect(buffer.node)
+
-      node.connect(keyboard.node)
+      computer.node.connect(buffer.node)
+      computer.node.connect(distributor.node)
+      computer.node.connect(gpu.node)
+      distributor.node.connect(battery)
+      buffer.node.connect(keyboard.node)
     }
+    super.onConnect(node)
   }
 
   override def onDisconnect(node: Node) {
     super.onDisconnect(node)
     if (node == this.node) {
-      gpu.node.remove()
+      battery.remove()
       buffer.node.remove()
+      computer.node.remove()
+      distributor.node.remove()
+      gpu.node.remove()
       keyboard.node.remove()
     }
   }
 
+  override protected def connectItemNode(node: Node) {
+    computer.node.connect(node)
+  }
+
   // ----------------------------------------------------------------------- //
 
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
     if (isServer) {
-      buffer.node.load(nbt.getCompoundTag(Config.namespace + "buffer"))
+      battery.load(nbt.getCompoundTag(Config.namespace + "battery"))
       buffer.load(nbt.getCompoundTag(Config.namespace + "buffer"))
       gpu.load(nbt.getCompoundTag(Config.namespace + "gpu"))
-      keyboard.node.load(nbt.getCompoundTag(Config.namespace + "keyboard"))
+      keyboard.load(nbt.getCompoundTag(Config.namespace + "keyboard"))
     }
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
     if (isServer) {
-      val bufferNbt = new NBTTagCompound()
+      nbt.setNewCompoundTag(Config.namespace + "battery", battery.save)
-      buffer.node.save(bufferNbt)
+      nbt.setNewCompoundTag(Config.namespace + "buffer", buffer.save)
-      buffer.save(bufferNbt)
+      nbt.setNewCompoundTag(Config.namespace + "gpu", gpu.save)
-      nbt.setCompoundTag(Config.namespace + "buffer", bufferNbt)
+      nbt.setNewCompoundTag(Config.namespace + "keyboard", keyboard.save)
-
-      val gpuNbt = new NBTTagCompound()
-      gpu.save(gpuNbt)
-      nbt.setCompoundTag(Config.namespace + "gpu", gpuNbt)
-
-      val keyboardNbt = new NBTTagCompound()
-      keyboard.node.save(keyboardNbt)
-      nbt.setCompoundTag(Config.namespace + "keyboard", keyboardNbt)
     }
   }
 
@@ -173,7 +203,8 @@ class Robot(isRemote: Boolean) extends Computer(isRemote) with Buffer.Environmen
 
   def isItemValidForSlot(slot: Int, item: ItemStack) = (slot, Registry.driverFor(item)) match {
     case (0, Some(driver)) => driver.slot(item) == Slot.Tool
-    case (1 | 2, Some(driver)) => driver.slot(item) == Slot.Card
+    case (1, Some(driver)) => driver.slot(item) == Slot.Card
+    case (2, Some(driver)) => driver.slot(item) == Slot.HardDiskDrive
     case (3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11, _) => true // Normal inventory.
     case _ => false // Invalid slot.
   }

li/cil/oc/common/tileentity/Rotatable.scala

@@ -154,16 +154,16 @@ trait Rotatable extends TileEntity with Persistable {
   override def load(nbt: NBTTagCompound) = {
     super.load(nbt)
 
-    _pitch = ForgeDirection.getOrientation(nbt.getInteger(Config.namespace + "rotatable.pitch"))
+    _pitch = ForgeDirection.getOrientation(nbt.getInteger(Config.namespace + "pitch"))
-    _yaw = ForgeDirection.getOrientation(nbt.getInteger(Config.namespace + "rotatable.yaw"))
+    _yaw = ForgeDirection.getOrientation(nbt.getInteger(Config.namespace + "yaw"))
     updateTranslation()
   }
 
   override def save(nbt: NBTTagCompound) = {
     super.save(nbt)
 
-    nbt.setInteger(Config.namespace + "rotatable.pitch", _pitch.ordinal)
+    nbt.setInteger(Config.namespace + "pitch", _pitch.ordinal)
-    nbt.setInteger(Config.namespace + "rotatable.yaw", _yaw.ordinal)
+    nbt.setInteger(Config.namespace + "yaw", _yaw.ordinal)
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/common/tileentity/Screen.scala

@@ -143,12 +143,12 @@ class Screen(var tier: Int) extends Buffer.Environment with Rotatable with Analy
   // ----------------------------------------------------------------------- //
 
   override def readFromNBT(nbt: NBTTagCompound) {
-    tier = nbt.getByte(Config.namespace + "screen.tier")
+    tier = nbt.getByte(Config.namespace + "tier")
     super.readFromNBT(nbt)
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
-    nbt.setByte(Config.namespace + "screen.tier", tier.toByte)
+    nbt.setByte(Config.namespace + "tier", tier.toByte)
     super.writeToNBT(nbt)
   }
 

li/cil/oc/server/PacketHandler.scala

@@ -57,31 +57,31 @@ class PacketHandler extends CommonPacketHandler {
     }
 
   def onKeyDown(p: PacketParser) =
-    p.readTileEntity[Environment]() match {
+    p.readTileEntity[Buffer.Environment]() match {
       case Some(s: Screen) =>
         val char = Char.box(p.readChar())
         val code = Int.box(p.readInt())
         s.screens.foreach(_.node.sendToNeighbors("keyboard.keyDown", p.player, char, code))
-      case Some(e) => e.node.sendToNeighbors("keyboard.keyDown", p.player, Char.box(p.readChar()), Int.box(p.readInt()))
+      case Some(e) => e.buffer.node.sendToNeighbors("keyboard.keyDown", p.player, Char.box(p.readChar()), Int.box(p.readInt()))
       case _ => // Invalid packet.
     }
 
   def onKeyUp(p: PacketParser) =
-    p.readTileEntity[Environment]() match {
+    p.readTileEntity[Buffer.Environment]() match {
       case Some(s: Screen) =>
         val char = Char.box(p.readChar())
         val code = Int.box(p.readInt())
         s.screens.foreach(_.node.sendToNeighbors("keyboard.keyUp", p.player, char, code))
-      case Some(e) => e.node.sendToNeighbors("keyboard.keyUp", p.player, Char.box(p.readChar()), Int.box(p.readInt()))
+      case Some(e) => e.buffer.node.sendToNeighbors("keyboard.keyUp", p.player, Char.box(p.readChar()), Int.box(p.readInt()))
       case _ => // Invalid packet.
     }
 
   def onClipboard(p: PacketParser) =
-    p.readTileEntity[Environment]() match {
+    p.readTileEntity[Buffer.Environment]() match {
       case Some(s: Screen) =>
         val value = p.readUTF()
         s.screens.foreach(_.node.sendToNeighbors("keyboard.clipboard", p.player, value))
-      case Some(e) => e.node.sendToNeighbors("keyboard.clipboard", p.player, p.readUTF())
+      case Some(e) => e.buffer.node.sendToNeighbors("keyboard.clipboard", p.player, p.readUTF())
       case _ => // Invalid packet.
     }
 }

li/cil/oc/server/PacketSender.scala

@@ -33,11 +33,11 @@ object PacketSender {
     }
   }
 
-  def sendPowerState(t: PowerDistributor, player: Option[Player] = None) {
+  def sendPowerState(t: PowerInformation, player: Option[Player] = None) {
     val pb = new PacketBuilder(PacketType.PowerStateResponse)
 
     pb.writeTileEntity(t)
-    pb.writeDouble(t.average)
+    pb.writeDouble(t.globalPower)
 
     player match {
       case Some(p) => pb.sendToPlayer(p)

li/cil/oc/server/component/Computer.scala

@@ -7,11 +7,11 @@ import java.util.concurrent._
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.logging.Level
 import li.cil.oc.api
-import li.cil.oc.api.Persistable
 import li.cil.oc.api.network._
 import li.cil.oc.common.tileentity
 import li.cil.oc.server
 import li.cil.oc.util.ExtendedLuaState.extendLuaState
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.{GameTimeFormatter, LuaStateFactory}
 import li.cil.oc.{OpenComputers, Config}
 import net.minecraft.entity.player.EntityPlayer
@@ -24,7 +24,7 @@ import scala.collection.mutable
 import scala.math.ScalaNumber
 import scala.runtime.BoxedUnit
 
-class Computer(val owner: tileentity.Computer) extends Environment with Context with Persistable with Runnable {
+class Computer(val owner: tileentity.Computer) extends ManagedComponent with Context with Runnable {
   val node = api.Network.newNode(this, Visibility.Network).
     withComponent("computer", Visibility.Neighbors).
     withConnector().
@@ -156,7 +156,7 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
 
   // ----------------------------------------------------------------------- //
 
-  def update() {
+  override def update() {
     // Add components that were added since the last update to the actual list
     // of components if we can see them. We use this delayed approach to avoid
     // issues with components that have a visibility lower than their
@@ -279,7 +279,7 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
 
   // ----------------------------------------------------------------------- //
 
-  def onConnect(node: Node) {
+  override def onConnect(node: Node) {
     if (node == this.node) {
       rom.foreach(rom => node.connect(rom.node))
       tmp.foreach(tmp => node.connect(tmp.node))
@@ -293,7 +293,7 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
     owner.onConnect(node)
   }
 
-  def onDisconnect(node: Node) {
+  override def onDisconnect(node: Node) {
     if (node == this.node) {
       stop()
       rom.foreach(_.node.remove())
@@ -308,7 +308,7 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
     owner.onDisconnect(node)
   }
 
-  def onMessage(message: Message) {
+  override def onMessage(message: Message) {
     message.data match {
       case Array(name: String, args@_*) if message.name == "computer.signal" =>
         signal(name, Seq(message.source.address) ++ args: _*)
@@ -365,26 +365,19 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
 
   // ----------------------------------------------------------------------- //
 
-  def load(nbt: NBTTagCompound) = this.synchronized {
+  override def load(nbt: NBTTagCompound) = this.synchronized {
     assert(state.top == Computer.State.Stopped)
     assert(future.isEmpty)
-
+    assert(users.isEmpty)
-    val computerNbt = nbt.getCompoundTag(Config.namespace + "computer")
+    assert(signals.isEmpty)
-
     state.clear()
-    val stateNbt = computerNbt.getTagList("state")
-    (0 until stateNbt.tagCount).
-      map(stateNbt.tagAt).
-      map(_.asInstanceOf[NBTTagInt]).
-      foreach(s => state.push(Computer.State(s.data)))
 
-    val usersNbt = computerNbt.getTagList("users")
+    super.load(nbt)
-    (0 until usersNbt.tagCount).
-      map(usersNbt.tagAt).
-      map(_.asInstanceOf[NBTTagString]).
-      foreach(u => users += u.data)
 
-    if (state.top != Computer.State.Stopped && init()) {
+    nbt.getTagList("state").foreach[NBTTagInt](s => state.push(Computer.State(s.data)))
+    nbt.getTagList("users").foreach[NBTTagString](u => users += u.data)
+
+    if (state.size > 0 && state.top != Computer.State.Stopped && init()) {
       // Unlimit memory use while unpersisting.
       lua.setTotalMemory(Integer.MAX_VALUE)
 
@@ -393,14 +386,14 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
         // on. First, clear the stack, meaning the current kernel.
         lua.setTop(0)
 
-        unpersist(computerNbt.getByteArray("kernel"))
+        unpersist(nbt.getByteArray("kernel"))
         if (!lua.isThread(1)) {
           // This shouldn't really happen, but there's a chance it does if
           // the save was corrupt (maybe someone modified the Lua files).
           throw new IllegalArgumentException("Invalid kernel.")
         }
         if (state.contains(Computer.State.SynchronizedCall) || state.contains(Computer.State.SynchronizedReturn)) {
-          unpersist(computerNbt.getByteArray("stack"))
+          unpersist(nbt.getByteArray("stack"))
           if (!(if (state.contains(Computer.State.SynchronizedCall)) lua.isFunction(2) else lua.isTable(2))) {
             // Same as with the above, should not really happen normally, but
             // could for the same reasons.
@@ -408,17 +401,11 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
           }
         }
 
-        val componentsNbt = computerNbt.getTagList("components")
+        val componentsNbt = nbt.getTagList("components")
-        components ++= (0 until componentsNbt.tagCount).
+        components ++= componentsNbt.iterator[NBTTagCompound].map(c =>
-          map(componentsNbt.tagAt).
+          c.getString("address") -> c.getString("name"))
-          map(_.asInstanceOf[NBTTagCompound]).
-          map(c => c.getString("address") -> c.getString("name"))
 
-        val signalsNbt = computerNbt.getTagList("signals")
+        signals ++= nbt.getTagList("signals").iterator[NBTTagCompound].map(signalNbt => {
-        signals ++= (0 until signalsNbt.tagCount).
-          map(signalsNbt.tagAt).
-          map(_.asInstanceOf[NBTTagCompound]).
-          map(signalNbt => {
           val argsNbt = signalNbt.getCompoundTag("args")
           val argsLength = argsNbt.getInteger("length")
           new Computer.Signal(signalNbt.getString("name"),
@@ -432,21 +419,13 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
             }.toArray)
         })
 
-        rom.foreach(rom => {
+        rom.foreach(rom => rom.load(nbt.getCompoundTag("rom")))
-          val romNbt = computerNbt.getCompoundTag("rom")
+        tmp.foreach(tmp => tmp.load(nbt.getCompoundTag("tmp")))
-          rom.node.load(romNbt)
+        kernelMemory = nbt.getInteger("kernelMemory")
-          rom.load(romNbt)
+        timeStarted = nbt.getLong("timeStarted")
-        })
+        cpuTime = nbt.getLong("cpuTime")
-        tmp.foreach(tmp => {
+        if (nbt.hasKey("message")) {
-          val tmpNbt = computerNbt.getCompoundTag("tmp")
+          message = Some(nbt.getString("message"))
-          tmp.node.load(tmpNbt)
-          tmp.load(tmpNbt)
-        })
-        kernelMemory = computerNbt.getInteger("kernelMemory")
-        timeStarted = computerNbt.getLong("timeStarted")
-        cpuTime = computerNbt.getLong("cpuTime")
-        if (computerNbt.hasKey("message")) {
-          message = Some(computerNbt.getString("message"))
         }
 
         // Limit memory again.
@@ -466,26 +445,17 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
     else close() // Clean up in case we got a weird state stack.
   }
 
-  def save(nbt: NBTTagCompound): Unit = this.synchronized {
+  override def save(nbt: NBTTagCompound): Unit = this.synchronized {
     assert(state.top != Computer.State.Running) // Lock on 'this' should guarantee this.
     assert(state.top != Computer.State.Stopping) // Only set while executor is running.
 
+    super.save(nbt)
+
     // Make sure the component list is up-to-date.
     processAddedComponents()
 
-    val computerNbt = new NBTTagCompound()
+    nbt.setNewTagList("state", state.map(_.id))
-
+    nbt.setNewTagList("users", users)
-    val stateNbt = new NBTTagList()
-    for (state <- state) {
-      stateNbt.appendTag(new NBTTagInt(null, state.id))
-    }
-    computerNbt.setTag("state", stateNbt)
-
-    val usersNbt = new NBTTagList()
-    for (user <- users) {
-      usersNbt.appendTag(new NBTTagString(null, user))
-    }
-    computerNbt.setTag("users", usersNbt)
 
     if (state.top != Computer.State.Stopped) {
       // Unlimit memory while persisting.
@@ -495,12 +465,12 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
         // Try persisting Lua, because that's what all of the rest depends on.
         // Save the kernel state (which is always at stack index one).
         assert(lua.isThread(1))
-        computerNbt.setByteArray("kernel", persist(1))
+        nbt.setByteArray("kernel", persist(1))
         // While in a driver call we have one object on the global stack: either
         // the function to call the driver with, or the result of the call.
         if (state.contains(Computer.State.SynchronizedCall) || state.contains(Computer.State.SynchronizedReturn)) {
           assert(if (state.contains(Computer.State.SynchronizedCall)) lua.isFunction(2) else lua.isTable(2))
-          computerNbt.setByteArray("stack", persist(2))
+          nbt.setByteArray("stack", persist(2))
         }
 
         val componentsNbt = new NBTTagList()
@@ -510,56 +480,43 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
           componentNbt.setString("name", name)
           componentsNbt.appendTag(componentNbt)
         }
-        computerNbt.setTag("components", componentsNbt)
+        nbt.setTag("components", componentsNbt)
 
         val signalsNbt = new NBTTagList()
         for (s <- signals.iterator) {
           val signalNbt = new NBTTagCompound()
           signalNbt.setString("name", s.name)
-          val args = new NBTTagCompound()
+          signalNbt.setNewCompoundTag("args", args => {
-          args.setInteger("length", s.args.length)
+            args.setInteger("length", s.args.length)
-          s.args.zipWithIndex.foreach {
+            s.args.zipWithIndex.foreach {
-            case (Unit, i) => args.setByte("arg" + i, -1)
+              case (Unit, i) => args.setByte("arg" + i, -1)
-            case (arg: Boolean, i) => args.setByte("arg" + i, if (arg) 1 else 0)
+              case (arg: Boolean, i) => args.setByte("arg" + i, if (arg) 1 else 0)
-            case (arg: Double, i) => args.setDouble("arg" + i, arg)
+              case (arg: Double, i) => args.setDouble("arg" + i, arg)
-            case (arg: String, i) => args.setString("arg" + i, arg)
+              case (arg: String, i) => args.setString("arg" + i, arg)
-            case (arg: Array[Byte], i) => args.setByteArray("arg" + i, arg)
+              case (arg: Array[Byte], i) => args.setByteArray("arg" + i, arg)
-          }
+            }
-          signalNbt.setCompoundTag("args", args)
+          })
           signalsNbt.appendTag(signalNbt)
         }
-        computerNbt.setTag("signals", signalsNbt)
+        nbt.setTag("signals", signalsNbt)
 
-        val romNbt = new NBTTagCompound()
+        rom.foreach(rom => nbt.setNewCompoundTag("rom", rom.save))
-        rom.foreach(rom => {
+        tmp.foreach(tmp => nbt.setNewCompoundTag("tmp", tmp.save))
-          rom.save(romNbt)
-          rom.node.save(romNbt)
-        })
-        computerNbt.setCompoundTag("rom", romNbt)
 
-        val tmpNbt = new NBTTagCompound()
+        nbt.setInteger("kernelMemory", kernelMemory)
-        tmp.foreach(tmp => {
+        nbt.setLong("timeStarted", timeStarted)
-          tmp.save(tmpNbt)
+        nbt.setLong("cpuTime", cpuTime)
-          tmp.node.save(tmpNbt)
+        message.foreach(nbt.setString("message", _))
-        })
-        computerNbt.setCompoundTag("tmp", tmpNbt)
-
-        computerNbt.setInteger("kernelMemory", kernelMemory)
-        computerNbt.setLong("timeStarted", timeStarted)
-        computerNbt.setLong("cpuTime", cpuTime)
-        message.foreach(computerNbt.setString("message", _))
       } catch {
         case e: LuaRuntimeException => {
           OpenComputers.log.warning("Could not persist computer.\n" + e.toString + "\tat " + e.getLuaStackTrace.mkString("\n\tat "))
-          computerNbt.setInteger("state", Computer.State.Stopped.id)
+          nbt.removeTag("state")
         }
       }
 
       // Limit memory again.
       recomputeMemory()
     }
-
-    nbt.setCompoundTag(Config.namespace + "computer", computerNbt)
   }
 
   private def persist(index: Int): Array[Byte] = {
@@ -1086,7 +1043,7 @@ class Computer(val owner: tileentity.Computer) extends Environment with Context
   }
 
   private def close() = state.synchronized(
-    if (state.top != Computer.State.Stopped) {
+    if (state.size == 0 || state.top != Computer.State.Stopped) {
       state.clear()
       state.push(Computer.State.Stopped)
       lua.setTotalMemory(Integer.MAX_VALUE)

li/cil/oc/server/component/Filesystem.scala

@@ -3,6 +3,7 @@ package li.cil.oc.server.component
 import java.io.{FileNotFoundException, IOException}
 import li.cil.oc.api.fs.{Label, Mode}
 import li.cil.oc.api.network._
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.{Config, api}
 import net.minecraft.nbt.{NBTTagInt, NBTTagList, NBTTagCompound}
 import scala.Some
@@ -228,6 +229,7 @@ class FileSystem(val fileSystem: api.fs.FileSystem, var label: Label) extends Ma
 
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
+
     val ownersNbt = nbt.getTagList("owners")
     (0 until ownersNbt.tagCount).map(ownersNbt.tagAt).map(_.asInstanceOf[NBTTagCompound]).foreach(ownerNbt => {
       val address = ownerNbt.getString("address")
@@ -245,6 +247,7 @@ class FileSystem(val fileSystem: api.fs.FileSystem, var label: Label) extends Ma
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
+
     val ownersNbt = new NBTTagList()
     for ((address, handles) <- owners) {
       val ownerNbt = new NBTTagCompound()
@@ -258,9 +261,7 @@ class FileSystem(val fileSystem: api.fs.FileSystem, var label: Label) extends Ma
     }
     nbt.setTag("owners", ownersNbt)
 
-    val fsNbt = new NBTTagCompound()
+    nbt.setNewCompoundTag("fs", fileSystem.save)
-    fileSystem.save(fsNbt)
-    nbt.setCompoundTag("fs", fsNbt)
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/server/component/GraphicsCard.scala

@@ -207,16 +207,18 @@ abstract class GraphicsCard extends ManagedComponent {
 
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
-    if (nbt.hasKey(Config.namespace + "gpu.screen")) {
+
-      screenAddress = Some(nbt.getString(Config.namespace + "gpu.screen"))
+    if (nbt.hasKey("screen")) {
+      screenAddress = Some(nbt.getString("screen"))
       screenInstance = None
     }
   }
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
+
     if (screenAddress.isDefined) {
-      nbt.setString(Config.namespace + "gpu.screen", screenAddress.get)
+      nbt.setString("screen", screenAddress.get)
     }
   }
 }

li/cil/oc/server/component/Keyboard.scala

@@ -1,7 +1,6 @@
 package li.cil.oc.server.component
 
 import cpw.mods.fml.common.IPlayerTracker
-import li.cil.oc.api
 import li.cil.oc.api.Network
 import li.cil.oc.api.network.{Node, Visibility, Message}
 import li.cil.oc.common.tileentity.Environment
@@ -13,7 +12,7 @@ import scala.collection.mutable
 // TODO key up when screen is disconnected from which the key down came
 // TODO key up after load for anything that was pressed
 
-class Keyboard(owner: Environment) extends api.network.Environment {
+class Keyboard(owner: Environment) extends ManagedComponent {
   val node = Network.newNode(this, Visibility.Network).
     withComponent("keyboard").
     create()
@@ -34,19 +33,19 @@ class Keyboard(owner: Environment) extends api.network.Environment {
 
   // ----------------------------------------------------------------------- //
 
-  def onConnect(node: Node) {
+  override def onConnect(node: Node) {
     if (node == this.node) {
       MinecraftForge.EVENT_BUS.register(this)
     }
   }
 
-  def onDisconnect(node: Node) {
+  override def onDisconnect(node: Node) {
     if (node == this.node) {
       MinecraftForge.EVENT_BUS.unregister(this)
     }
   }
 
-  def onMessage(message: Message) = {
+  override def onMessage(message: Message) = {
     message.data match {
       case Array(p: EntityPlayer, char: Character, code: Integer) if message.name == "keyboard.keyDown" =>
         if (isUseableByPlayer(p)) {

li/cil/oc/server/component/ManagedComponent.scala

@@ -1,6 +1,7 @@
 package li.cil.oc.server.component
 
 import li.cil.oc.api.network.{ManagedEnvironment, Node, Message}
+import li.cil.oc.util.ExtendedNBT._
 import net.minecraft.nbt.NBTTagCompound
 import scala.math.ScalaNumber
 
@@ -14,11 +15,11 @@ abstract class ManagedComponent extends ManagedEnvironment {
   def onConnect(node: Node) {}
 
   def load(nbt: NBTTagCompound) = {
-    if (node != null) node.load(nbt)
+    if (node != null) node.load(nbt.getCompoundTag("node"))
   }
 
   def save(nbt: NBTTagCompound) = {
-    if (node != null) node.save(nbt)
+    if (node != null) nbt.setNewCompoundTag("node", node.save)
   }
 
   /**

li/cil/oc/server/component/NetworkCard.scala

@@ -1,8 +1,9 @@
 package li.cil.oc.server.component
 
+import li.cil.oc.api
 import li.cil.oc.api.network._
-import li.cil.oc.{Config, api}
+import li.cil.oc.util.ExtendedNBT._
-import net.minecraft.nbt.{NBTTagInt, NBTTagList, NBTTagCompound}
+import net.minecraft.nbt.{NBTTagInt, NBTTagCompound}
 import scala.collection.convert.WrapAsScala._
 import scala.collection.mutable
 
@@ -81,19 +82,15 @@ class NetworkCard extends ManagedComponent {
 
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
-    val openPortsNbt = nbt.getTagList(Config.namespace + "modem.openPorts")
+
-    (0 until openPortsNbt.tagCount).
+    assert(openPorts.isEmpty)
-      map(openPortsNbt.tagAt).
+    openPorts ++ nbt.getTagList("openPorts").iterator[NBTTagInt].map(_.data)
-      map(_.asInstanceOf[NBTTagInt]).
-      foreach(portNbt => openPorts.add(portNbt.data))
   }
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
-    val openPortsNbt = new NBTTagList()
+
-    for (port <- openPorts)
+    nbt.setNewTagList("openPorts", openPorts)
-      openPortsNbt.appendTag(new NBTTagInt(null, port))
-    nbt.setTag(Config.namespace + "modem.openPorts", openPortsNbt)
   }
 
   // ----------------------------------------------------------------------- //

li/cil/oc/server/component/PowerDistributor.scala

@@ -0,0 +1,170 @@
+package li.cil.oc.server.component
+
+import li.cil.oc.api
+import li.cil.oc.api.network._
+import li.cil.oc.common.tileentity.PowerInformation
+import li.cil.oc.server.network.Connector
+import li.cil.oc.server.{PacketSender => ServerPacketSender}
+import scala.collection.convert.WrapAsScala._
+import scala.collection.mutable
+
+class PowerDistributor(val owner: PowerInformation) extends ManagedComponent {
+
+  val node = api.Network.newNode(this, Visibility.Network).
+    withComponent("power", Visibility.Network).
+    create()
+
+  var globalBuffer = 0.0
+
+  var globalBufferSize = 0.0
+
+  private var lastSentState = 0.0
+
+  private val buffers = mutable.Set.empty[Connector]
+
+  private val distributors = mutable.Set.empty[PowerDistributor]
+
+  private var dirty = true
+
+  // ----------------------------------------------------------------------- //
+
+  @LuaCallback(value = "buffer", direct = true)
+  def buffer(context: Context, args: Arguments): Array[AnyRef] = result(globalBuffer)
+
+  @LuaCallback(value = "bufferSize", direct = true)
+  def bufferSize(context: Context, args: Arguments): Array[AnyRef] = result(globalBufferSize)
+
+  // ----------------------------------------------------------------------- //
+
+  def changeBuffer(delta: Double): Boolean = {
+    if (delta != 0) this.synchronized {
+      val oldBuffer = globalBuffer
+      globalBuffer = (globalBuffer + delta) max 0 min globalBufferSize
+      if (globalBuffer != oldBuffer) {
+        dirty = true
+        if (delta < 0) {
+          var remaining = -delta
+          for (connector <- buffers) {
+            connector.synchronized(if (connector.localBuffer > 0) {
+              connector.dirty = true
+              if (connector.localBuffer < remaining) {
+                remaining -= connector.localBuffer
+                connector.localBuffer = 0
+              }
+              else {
+                connector.localBuffer -= remaining
+                return true
+              }
+            })
+          }
+        }
+        else if (delta > 0) {
+          var remaining = delta
+          for (connector <- buffers) {
+            connector.synchronized(if (connector.localBuffer < connector.localBufferSize) {
+              connector.dirty = true
+              val space = connector.localBufferSize - connector.localBuffer
+              if (space < remaining) {
+                remaining -= space
+                connector.localBuffer = connector.localBufferSize
+              }
+              else {
+                connector.localBuffer += remaining
+                return true
+              }
+            })
+          }
+        }
+      }
+    }
+    false
+  }
+
+  // ----------------------------------------------------------------------- //
+
+  override def update() {
+    if (node != null && (dirty || buffers.exists(_.dirty))) {
+      updateCachedValues()
+    }
+  }
+
+  // ----------------------------------------------------------------------- //
+
+  override def onConnect(node: Node) {
+    super.onConnect(node)
+    if (node == this.node) {
+      for (node <- node.reachableNodes) node match {
+        case connector: Connector if connector.localBufferSize > 0 => this.synchronized {
+          buffers += connector
+          globalBuffer += connector.localBuffer
+          globalBufferSize += connector.localBufferSize
+        }
+        case _ => node.host match {
+          case distributor: PowerDistributor if distributor.node.canBeSeenFrom(this.node) =>
+            distributors += distributor
+          case _ =>
+        }
+      }
+      distributors += this
+      dirty = true
+    }
+    else node match {
+      case connector: Connector if connector.localBufferSize > 0 => this.synchronized {
+        buffers += connector
+        globalBuffer += connector.localBuffer
+        globalBufferSize += connector.localBufferSize
+        dirty = true
+      }
+      case _ => node.host match {
+        case distributor: PowerDistributor if distributor.node.canBeSeenFrom(this.node) =>
+          distributors += distributor
+        case _ =>
+      }
+    }
+  }
+
+  override def onDisconnect(node: Node) {
+    super.onDisconnect(node)
+    if (node == this.node) this.synchronized {
+      buffers.clear()
+      distributors.clear()
+      globalBuffer = 0
+      globalBufferSize = 0
+    }
+    else node match {
+      case connector: Connector => this.synchronized {
+        buffers -= connector
+        globalBuffer -= connector.localBuffer
+        globalBufferSize -= connector.localBufferSize
+        dirty = true
+      }
+      case _ => node.host match {
+        case distributor: PowerDistributor => distributors -= distributor
+        case _ =>
+      }
+    }
+  }
+
+  // ----------------------------------------------------------------------- //
+
+  def updateCachedValues() {
+    // Computer average fill ratio of all buffers.
+    val (sumBuffer, sumBufferSize) =
+      buffers.foldRight((0.0, 0.0))((c, acc) => {
+        c.dirty = false // clear dirty flag for all connectors
+        (acc._1 + c.localBuffer, acc._2 + c.localBufferSize)
+      })
+    val globalPower = if (globalBufferSize > 0) globalBuffer / globalBufferSize else 0
+    val shouldSend = (lastSentState - globalPower).abs > 0.05
+    for (distributor <- distributors) distributor.synchronized {
+      distributor.dirty = false
+      distributor.globalBuffer = sumBuffer
+      distributor.globalBufferSize = sumBufferSize
+      distributor.owner.globalPower = globalPower
+      if (shouldSend) {
+        distributor.lastSentState = lastSentState
+        ServerPacketSender.sendPowerState(owner)
+      }
+    }
+  }
+}

li/cil/oc/server/component/PowerSupply.scala

@@ -1,11 +1,10 @@
 package li.cil.oc.server.component
 
-import li.cil.oc.api.network.{Context, Arguments, LuaCallback, Visibility}
+import li.cil.oc.api.network.Visibility
 import li.cil.oc.{Config, api}
 
 class PowerSupply extends ManagedComponent {
   val node = api.Network.newNode(this, Visibility.Network).
-    withComponent("psu").
     withConnector(Config.bufferPowerSupply).
     create()
 
@@ -13,10 +12,4 @@ class PowerSupply extends ManagedComponent {
     super.update()
     node.changeBuffer(-Config.powerSupplyCost)
   }
-
-  @LuaCallback(value = "localBufferSize", direct = true)
-  def bufferSize(context: Context, args: Arguments): Array[AnyRef] = result(node.localBufferSize)
-
-  @LuaCallback(value = "localBuffer", direct = true)
-  def buffer(context: Context, args: Arguments): Array[AnyRef] = result(node.localBuffer)
 }

li/cil/oc/server/component/WirelessNetworkCard.scala

@@ -86,13 +86,13 @@ class WirelessNetworkCard(val owner: TileEntity) extends NetworkCard {
 
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
-    if (nbt.hasKey(Config.namespace + "modem.strength")) {
+    if (nbt.hasKey("modem")) {
-      strength = nbt.getDouble(Config.namespace + "modem.strength")
+      strength = nbt.getDouble("strength")
     }
   }
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
-    nbt.setDouble(Config.namespace + "modem.strength", strength)
+    nbt.setDouble("strength", strength)
   }
 }

li/cil/oc/server/network/Connector.scala

@@ -3,7 +3,7 @@ package li.cil.oc.server.network
 import li.cil.oc.Config
 import li.cil.oc.api.network
 import li.cil.oc.api.network.{Node => ImmutableNode}
-import li.cil.oc.common.tileentity.PowerDistributor
+import li.cil.oc.server.component.PowerDistributor
 import li.cil.oc.util.Persistable
 import net.minecraft.nbt.NBTTagCompound
 import scala.collection.convert.WrapAsScala._
@@ -51,14 +51,15 @@ trait Connector extends Node with network.Connector with Persistable {
   override def onConnect(node: ImmutableNode) {
     if (node == this) findDistributor()
     else if (distributor.isEmpty) node.host match {
-      case distributor: PowerDistributor => this.distributor = Some(distributor)
+      case distributor: PowerDistributor =>
+        this.distributor = Some(distributor)
       case _ =>
     }
     super.onConnect(node)
   }
 
   override def onDisconnect(node: ImmutableNode) {
-    if (node != this && distributor.exists(_ == node.host)) findDistributor()
+    if (node != this && distributor.exists(_ == node)) findDistributor()
     super.onDisconnect(node)
   }
 
@@ -70,12 +71,12 @@ trait Connector extends Node with network.Connector with Persistable {
 
   override def load(nbt: NBTTagCompound) {
     super.load(nbt)
-    localBuffer = nbt.getDouble(Config.namespace + "connector.buffer") max 0 min localBufferSize
+    localBuffer = nbt.getDouble("buffer") max 0 min localBufferSize
     dirty = true
   }
 
   override def save(nbt: NBTTagCompound) {
     super.save(nbt)
-    nbt.setDouble(Config.namespace + "connector.buffer", localBuffer)
+    nbt.setDouble("buffer", localBuffer)
   }
 }

li/cil/oc/server/network/Network.scala

@@ -259,6 +259,8 @@ object Network extends api.detail.NetworkAPI {
       case _ => // Invalid block.
     }
 
+  def create(node: ImmutableNode): Unit = new Network(node.asInstanceOf[MutableNode])
+
   private def getNetworkNode(world: IBlockAccess, x: Int, y: Int, z: Int) =
     Option(Block.blocksList(world.getBlockId(x, y, z))) match {
       case Some(block) if block.hasTileEntity(world.getBlockMetadata(x, y, z)) =>

li/cil/oc/server/network/Node.scala

@@ -1,8 +1,8 @@
 package li.cil.oc.server.network
 
+import li.cil.oc.api
 import li.cil.oc.api.network.{Environment, Visibility, Node => ImmutableNode}
 import li.cil.oc.util.Persistable
-import li.cil.oc.{Config, api}
 import net.minecraft.nbt.NBTTagCompound
 import scala.collection.convert.WrapAsJava._
 import scala.collection.convert.WrapAsScala._
@@ -64,15 +64,15 @@ trait Node extends api.network.Node with Persistable {
 
   override def load(nbt: NBTTagCompound) = {
     super.load(nbt)
-    if (nbt.hasKey(Config.namespace + "node.address")) {
+    if (nbt.hasKey("address")) {
-      address = nbt.getString(Config.namespace + "node.address")
+      address = nbt.getString("address")
     }
   }
 
   override def save(nbt: NBTTagCompound) = {
     super.save(nbt)
     if (address != null) {
-      nbt.setString(Config.namespace + "node.address", address)
+      nbt.setString("address", address)
     }
   }
 }

li/cil/oc/util/ExtendedLuaState.scala

@@ -7,7 +7,7 @@ object ExtendedLuaState {
 
   implicit def extendLuaState(state: LuaState) = new ExtendedLuaState(state)
 
-  class ExtendedLuaState(state: LuaState) {
+  class ExtendedLuaState(val state: LuaState) {
     def pushScalaFunction(f: (LuaState) => Int) = state.pushJavaFunction(new JavaFunction {
       override def invoke(state: LuaState) = f(state)
     })

li/cil/oc/util/ExtendedNBT.scala

@@ -0,0 +1,84 @@
+package li.cil.oc.util
+
+import net.minecraft.nbt._
+import scala.language.implicitConversions
+
+object ExtendedNBT {
+
+  implicit def toNbt(value: Byte) = new NBTTagByte(null, value)
+
+  implicit def toNbt(value: Short) = new NBTTagShort(null, value)
+
+  implicit def toNbt(value: Int) = new NBTTagInt(null, value)
+
+  implicit def toNbt(value: Long) = new NBTTagLong(null, value)
+
+  implicit def toNbt(value: Float) = new NBTTagFloat(null, value)
+
+  implicit def toNbt(value: Double) = new NBTTagDouble(null, value)
+
+  implicit def toNbt(value: Array[Byte]) = new NBTTagByteArray(null, value)
+
+  implicit def toNbt(value: String) = new NBTTagString(null, value)
+
+  implicit def byteIterableToNbt(value: Iterable[Byte]) = value.map(toNbt)
+
+  implicit def shortIterableToNbt(value: Iterable[Short]) = value.map(toNbt)
+
+  implicit def intIterableToNbt(value: Iterable[Int]) = value.map(toNbt)
+
+  implicit def longIterableToNbt(value: Iterable[Long]) = value.map(toNbt)
+
+  implicit def floatIterableToNbt(value: Iterable[Float]) = value.map(toNbt)
+
+  implicit def doubleIterableToNbt(value: Iterable[Double]) = value.map(toNbt)
+
+  implicit def byteArrayIterableToNbt(value: Iterable[Array[Byte]]) = value.map(toNbt)
+
+  implicit def stringIterableToNbt(value: Iterable[String]) = value.map(toNbt)
+
+  implicit def extendNBTTagCompound(nbt: NBTTagCompound) = new ExtendedNBTTagCompound(nbt)
+
+  implicit def extendNBTTagList(nbt: NBTTagList) = new ExtendedNBTTagList(nbt)
+
+  class ExtendedNBTTagCompound(val nbt: NBTTagCompound) {
+    def setNewCompoundTag(name: String, f: (NBTTagCompound) => Any) = {
+      val t = new NBTTagCompound()
+      f(t)
+      nbt.setCompoundTag(name, t)
+      nbt
+    }
+
+    def setNewTagList(name: String, values: Iterable[NBTBase]) = {
+      val t = new NBTTagList()
+      t.append(values)
+      nbt.setTag(name, t)
+      nbt
+    }
+
+    def setNewTagList(name: String, values: NBTBase*): NBTTagCompound = setNewTagList(name, values)
+  }
+
+  class ExtendedNBTTagList(val nbt: NBTTagList) {
+    def appendNewCompoundTag(f: (NBTTagCompound) => Unit) {
+      val t = new NBTTagCompound()
+      f(t)
+      nbt.appendTag(t)
+    }
+
+    def append(values: Iterable[NBTBase]) {
+      for (value <- values) {
+        nbt.appendTag(value)
+      }
+    }
+
+    def append(values: NBTBase*): Unit = append(values)
+
+    def iterator[Tag <: NBTBase] = (0 until nbt.tagCount).map(nbt.tagAt).map(_.asInstanceOf[Tag])
+
+    def foreach[Tag <: NBTBase](f: (Tag) => Unit) = iterator[Tag].foreach(f)
+
+    def map[Tag <: NBTBase, Value](f: (Tag) => Value) = iterator[Tag].map(f)
+  }
+
+}

li/cil/oc/util/RenderState.scala

@@ -39,6 +39,20 @@ object RenderState {
     }
   }
 
+  def enableLighting() {
+    GL11.glEnable(GL11.GL_LIGHTING)
+    if (arb) {
+      ARBMultitexture.glActiveTextureARB(OpenGlHelper.lightmapTexUnit)
+      GL11.glEnable(GL11.GL_TEXTURE_2D)
+      ARBMultitexture.glActiveTextureARB(OpenGlHelper.defaultTexUnit)
+    }
+    else {
+      GL13.glActiveTexture(OpenGlHelper.lightmapTexUnit)
+      GL11.glEnable(GL11.GL_TEXTURE_2D)
+      GL13.glActiveTexture(OpenGlHelper.defaultTexUnit)
+    }
+  }
+
   def makeItBlend() {
     GL11.glEnable(GL11.GL_BLEND)
     GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)