Added icons for tank upgrade and tank controller upgrade.

Added localizations for the same.
Added the tank controller upgrade.
Added recipes for the two.
Some fixery.

src/main/resources/application.conf

@@ -904,8 +904,9 @@ opencomputers {
 
       # Allow robots to get a table representation of item stacks using the
       # inventory controller upgrade? (i.e. whether the getStackInSlot method
-      # of said upgrade is enabled or not).
+      # of said upgrade is enabled or not). Also applies to tank controller
-      allowItemStackInspection: false
+      # upgrade and it's fluid getter method.
+      allowItemStackInspection: true
   }
 
   # Settings that are intended for debugging issues, not for normal use.
@@ -1000,5 +1001,9 @@ opencomputers {
       # not have an overly noticeable impact on performance, but it's disabled
       # by default because it is unnecessary in *most* cases.
       periodicallyForceLightUpdate: false
+
+      # Pass along IDs of items and fluids when converting them to a table
+      # representation for Lua.
+      insertIdsInConverters: false
   }
 }

src/main/resources/assets/opencomputers/lang/de_DE.lang

@@ -104,6 +104,8 @@ oc:item.UpgradeNavigation.name=Navigations-Upgrade
 oc:item.UpgradePiston.name=Kolben-Upgrade
 oc:item.UpgradeSign.name=Schild-I/O-Upgrade
 oc:item.UpgradeSolarGenerator.name=Solargenerator-Upgrade
+oc:item.UpgradeTank.name=Tank-Upgrade
+oc:item.UpgradeTankController.name=Tankbedienungs-Upgrade
 oc:item.UpgradeTractorBeam.name=Traktorstrahl-Upgrade
 oc:item.WirelessNetworkCard.name=Drahtlosnetzwerkkarte
 
@@ -262,5 +264,7 @@ oc:tooltip.UpgradeNavigation=Erlaubt es Robotern, ihre Position und Ausrichtung
 oc:tooltip.UpgradePiston=Dieses Upgrade erlaubt es zu drängeln. Es macht es möglich Blöcke zu verschieben, ähnlich dem Kolben. Es kann jedoch §lkeine§7 Entities bewegen.
 oc:tooltip.UpgradeSign=Erlaubt das Lesen und Schreiben von Text auf Schildern.
 oc:tooltip.UpgradeSolarGenerator=Kann verwendet werden, um unterwegs Energie aus Sonnenlicht zu generieren. Benötigt eine ungehinderte Sicht zum Himmel über dem Roboter. Generiert Energie mit %s%% der Geschwindigkeit eines Stirlingmotors.
+oc:tooltip.UpgradeTank=Dieses Upgrade gibt Robotern einen internen Tank. Ohne ein solches Upgrade können Roboter keine Flüssigkeiten verwahren.
+oc:tooltip.UpgradeTankController=Dieses Upgrade erlaubt es dem Roboter, präziser mit externen Tanks zu interagieren, und erlaubt es ihm, Flüssigkeiten in und aus sich im Inventar befindlichen Tank-Gegenständen zu pumpen.
 oc:tooltip.UpgradeTractorBeam=Stattet den Roboter mit unglaublich fortschrittlicher Technologie - Kosename: "Gegenstandsmagnet" - aus. Erlaubt es dem Roboter, Gegenstände, innerhalb von 3 Blöcken um sich herum, einzusammeln.
 oc:tooltip.WirelessNetworkCard=Erlaubt das drahtlose Senden von Netzwerknachrichten, zusätzlich zu normalen. Drahtlose Nachrichten werden nur gesendet, wenn eine §fSignalstärke§7 festgelegt wurde!

src/main/resources/assets/opencomputers/lang/en_US.lang

@@ -104,6 +104,8 @@ oc:item.UpgradeNavigation.name=Navigation Upgrade
 oc:item.UpgradePiston.name=Piston Upgrade
 oc:item.UpgradeSign.name=Sign I/O Upgrade
 oc:item.UpgradeSolarGenerator.name=Solar Generator Upgrade
+oc:item.UpgradeTank.name=Tank Upgrade
+oc:item.UpgradeTankController.name=Tank Controller Upgrade
 oc:item.UpgradeTractorBeam.name=Tractor Beam Upgrade
 oc:item.WirelessNetworkCard.name=Wireless Network Card
 
@@ -262,5 +264,7 @@ oc:tooltip.UpgradeNavigation=Can be used to determine the position and orientati
 oc:tooltip.UpgradePiston=This upgrade is very pushy. It allows moving blocks, similar to when using a piston. It does §lnot§7 move entities, however.
 oc:tooltip.UpgradeSign=Allows reading text on and writing text to signs.
 oc:tooltip.UpgradeSolarGenerator=Can be used to generate energy from sunlight on the go. Requires a clear line of sight to the sky above the robot. Generates energy at %s%% of the speed of a Stirling Engine.
+oc:tooltip.UpgradeTank=This upgrade provides a tank for fluid storage to the robot. Without one of these, robots will not be able to store fluids internally.
+oc:tooltip.UpgradeTankController=This upgrade allows the robot more control in how it interacts with external tanks, and allows it to transfer fluids into and out of fluid tank items in its inventory.
 oc:tooltip.UpgradeTractorBeam=Equips the robot with extremely advanced technology, nicknamed the "Item Magnet". Allows it to pick up items anywhere within 3 blocks of its location.
 oc:tooltip.WirelessNetworkCard=Allows wireless sending of network messages in addition to normal ones. You can adjust the §fsignal strength§7 to control how far messages are sent. Higher signal strength results in higher energy consumption.

src/main/resources/assets/opencomputers/recipes/default.recipes

@@ -196,6 +196,16 @@ solarGeneratorUpgrade {
           ["oc:circuitChip3", blockLapis, "oc:circuitChip3"]
           [ingotIron, "oc:materialCircuitBoardPrinted", ingotIron]]
 }
+tankUpgrade {
+  input: [[plankWood, fenceIron, plankWood]
+          [dispenser, cauldron, craftingPiston]
+          [plankWood, "oc:circuitChip1", plankWood]]
+}
+tankControllerUpgrade {
+  input: [[ingotGold, glassBottle, ingotGold]
+          [dispenser, "oc:circuitChip2", craftingPiston]
+          [ingotGold, "oc:materialCircuitBoardPrinted", ingotGold]]
+}
 tractorBeamUpgrade {
   input: [[ingotGold, craftingPiston, ingotGold]
           [ingotIron, "oc:capacitor", ingotIron]

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

@@ -261,7 +261,7 @@ object Items extends ItemAPI {
     // 1.3.5
     Recipes.addItem(new item.TabletCase(multi), "tabletCase", "oc:tabletCase")
     Recipes.addItem(new item.UpgradePiston(multi), "pistonUpgrade", "oc:pistonUpgrade")
-
+    Recipes.addItem(new item.UpgradeTank(multi), "tankUpgrade", "oc:tankUpgrade")
-    registerItem(new item.UpgradeTank(multi), "tankUpgrade")
+    Recipes.addItem(new item.UpgradeTankController(multi), "tankControllerUpgrade", "oc:tankControllerUpgrade")
   }
 }

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

@@ -254,6 +254,7 @@ class Settings(config: Config) {
   val disassembleAllTheThings = config.getBoolean("misc.disassembleAllTheThings")
   val disassemblerBreakChance = config.getDouble("misc.disassemblerBreakChance") max 0 min 1
   val hideOwnPet = config.getBoolean("misc.hideOwnSpecial")
+  val allowItemStackInspection = config.getBoolean("misc.allowItemStackInspection")
 
   // ----------------------------------------------------------------------- //
   // debug
@@ -271,6 +272,7 @@ class Settings(config: Config) {
   val debugPersistence = config.getBoolean("debug.verbosePersistenceErrors")
   val nativeInTmpDir = config.getBoolean("debug.nativeInTmpDir")
   val periodicallyForceLightUpdate = config.getBoolean("debug.periodicallyForceLightUpdate")
+  val insertIdsInConverters = config.getBoolean("debug.insertIdsInConverters")
 }
 
 object Settings {
@@ -358,6 +360,11 @@ object Settings {
       "computer.debug",
       "misc.alwaysTryNative",
       "misc.verbosePersistenceErrors"
+    ),
+    // Upgrading to version 1.3.5, added forgotten check for item stack,
+    // inspection, patch to true to avoid stuff suddenly breaking.
+    VersionRange.createFromVersionSpec("1.3.4") -> Array(
+      "misc.allowItemStackInspection"
     )
   )
 

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

@@ -100,6 +100,7 @@ class Proxy {
     api.Driver.add(driver.item.UpgradeSign)
     api.Driver.add(driver.item.UpgradeSolarGenerator)
     api.Driver.add(driver.item.UpgradeTank)
+    api.Driver.add(driver.item.UpgradeTankController)
     api.Driver.add(driver.item.UpgradeTractorBeam)
     api.Driver.add(driver.item.WirelessNetworkCard)
 
@@ -118,6 +119,7 @@ class Proxy {
     }
 
     OpenComputers.log.info("Initializing vanilla converters.")
+    api.Driver.add(driver.converter.FluidStack)
     api.Driver.add(driver.converter.FluidTankInfo)
     api.Driver.add(driver.converter.ItemStack)
 

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

@@ -0,0 +1,3 @@
+package li.cil.oc.common.item
+
+class UpgradeTankController(val parent: Delegator) extends Delegate with ItemTier

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

@@ -29,7 +29,7 @@ class UpgradeInventoryController(val owner: Container with Robot) extends compon
   }
 
   @Callback(doc = """function():table -- Get a description of the stack in the the inventory on the specified side of the robot. Back refers to the robot's own inventory.""")
-  def getStackInSlot(context: Context, args: Arguments): Array[AnyRef] = {
+  def getStackInSlot(context: Context, args: Arguments): Array[AnyRef] = if (Settings.get.allowItemStackInspection) {
     val facing = checkSideForInventory(args, 0)
     val slot = args.checkInteger(1) - 1
     if (facing == owner.facing.getOpposite) {
@@ -43,6 +43,7 @@ class UpgradeInventoryController(val owner: Container with Robot) extends compon
       case _ => result(Unit, "no inventory")
     }
   }
+  else result(Unit, "not enabled in config")
 
   @Callback(doc = """function(facing:number, slot:number[, count:number]):boolean -- Drops the selected item stack into the specified slot of an inventory.""")
   def dropIntoSlot(context: Context, args: Arguments): Array[AnyRef] = {

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

@@ -0,0 +1,125 @@
+package li.cil.oc.server.component
+
+import li.cil.oc.Settings
+import li.cil.oc.api.Network
+import li.cil.oc.api.driver.Container
+import li.cil.oc.api.network._
+import li.cil.oc.common.component
+import li.cil.oc.common.tileentity.Robot
+import li.cil.oc.util.ExtendedArguments._
+import net.minecraft.item.ItemStack
+import net.minecraftforge.common.ForgeDirection
+import net.minecraftforge.fluids.{IFluidContainerItem, FluidContainerRegistry, IFluidHandler}
+
+class UpgradeTankController(val owner: Container with Robot) extends component.ManagedComponent {
+  val node = Network.newNode(this, Visibility.Network).
+    withComponent("tank_controller", Visibility.Neighbors).
+    withConnector().
+    create()
+
+  // ----------------------------------------------------------------------- //
+
+  @Callback(doc = """function(side:number):number -- Get the capacity of the tank on the specified side of the robot. Back refers to the robot's own selected tank.""")
+  def getTankCapacity(context: Context, args: Arguments): Array[AnyRef] = {
+    val facing = checkSideForTank(args, 0)
+    if (facing == owner.facing.getOpposite) result(owner.getFluidTank(owner.selectedTank).fold(0)(_.getCapacity))
+    else owner.world.getBlockTileEntity(math.floor(owner.xPosition).toInt + facing.offsetX, math.floor(owner.yPosition).toInt + facing.offsetY, math.floor(owner.zPosition).toInt + facing.offsetZ) match {
+      case handler: IFluidHandler =>
+        result((owner.getFluidTank(owner.selectedTank) match {
+          case Some(tank) => handler.getTankInfo(facing.getOpposite).filter(info => info.fluid == null || info.fluid.isFluidEqual(tank.getFluid))
+          case _ => handler.getTankInfo(facing.getOpposite)
+        }).map(_.capacity).foldLeft(0)((max, capacity) => math.max(max, capacity)))
+      case _ => result(Unit, "no tank")
+    }
+  }
+
+  @Callback(doc = """function(side:number):table -- Get a description of the fluid in the the tank on the specified side of the robot. Back refers to the robot's own selected tank.""")
+  def getFluidInTank(context: Context, args: Arguments): Array[AnyRef] = if (Settings.get.allowItemStackInspection) {
+    val facing = checkSideForTank(args, 0)
+    if (facing == owner.facing.getOpposite) result(owner.getFluidTank(owner.selectedTank).map(_.getFluid).orNull)
+    else owner.world.getBlockTileEntity(math.floor(owner.xPosition).toInt + facing.offsetX, math.floor(owner.yPosition).toInt + facing.offsetY, math.floor(owner.zPosition).toInt + facing.offsetZ) match {
+      case handler: IFluidHandler => result(Option(handler.getTankInfo(facing.getOpposite)).map(_.map(_.fluid)).orNull)
+      case _ => result(Unit, "no tank")
+    }
+  }
+  else result(Unit, "not enabled in config")
+
+  @Callback(doc = """function([amount:number]):boolean -- Transfers fluid from a tank in the selected inventory slot to the selected tank.""")
+  def drain(context: Context, args: Arguments): Array[AnyRef] = {
+    val amount = args.optionalFluidCount(0)
+    owner.getFluidTank(owner.selectedTank) match {
+      case Some(tank) =>
+        owner.getStackInSlot(owner.selectedSlot) match {
+          case stack: ItemStack =>
+            if (FluidContainerRegistry.isFilledContainer(stack)) {
+              val contents = FluidContainerRegistry.getFluidForFilledItem(stack)
+              val container = stack.getItem.getContainerItemStack(stack)
+              if (tank.getCapacity - tank.getFluidAmount < contents.amount) {
+                result(Unit, "tank is full")
+              }
+              else if (tank.fill(contents, false) < contents.amount) {
+                result(Unit, "incompatible fluid")
+              }
+              else {
+                tank.fill(contents, true)
+                owner.decrStackSize(owner.selectedSlot, 1)
+                owner.player().inventory.addItemStackToInventory(container)
+                result(true)
+              }
+            }
+            else stack.getItem match {
+              case container: IFluidContainerItem =>
+                val drained = container.drain(stack, amount, false)
+                val transferred = tank.fill(drained, true)
+                if (transferred > 0) {
+                  container.drain(stack, transferred, true)
+                  result(true)
+                }
+                else result(Unit, "incompatible or no fluid")
+              case _ => result(Unit, "item is empty or not a fluid container")
+            }
+          case _ => result(Unit, "nothing selected")
+        }
+      case _ => result(Unit, "no tank")
+    }
+  }
+
+  @Callback(doc = """function([amount:number]):boolean -- Transfers fluid from the selected tank to a tank in the selected inventory slot.""")
+  def fill(context: Context, args: Arguments): Array[AnyRef] = {
+    val amount = args.optionalFluidCount(0)
+    owner.getFluidTank(owner.selectedTank) match {
+      case Some(tank) =>
+        owner.getStackInSlot(owner.selectedSlot) match {
+          case stack: ItemStack =>
+            if (FluidContainerRegistry.isEmptyContainer(stack)) {
+              val drained = tank.drain(amount, false)
+              val filled = FluidContainerRegistry.fillFluidContainer(drained, stack)
+              if (filled == null) {
+                result(Unit, "tank is empty")
+              }
+              else {
+                tank.drain(FluidContainerRegistry.getFluidForFilledItem(filled).amount, true)
+                owner.decrStackSize(owner.selectedSlot, 1)
+                owner.player().inventory.addItemStackToInventory(filled)
+                result(true)
+              }
+            }
+            else stack.getItem match {
+              case container: IFluidContainerItem =>
+                val drained = tank.drain(amount, false)
+                val transferred = container.fill(stack, drained, true)
+                if (transferred > 0) {
+                  tank.drain(transferred, true)
+                  result(true)
+                }
+                else result(Unit, "incompatible or no fluid")
+              case _ => result(Unit, "item is full or not a fluid container")
+            }
+          case _ => result(Unit, "nothing selected")
+        }
+      case _ => result(Unit, "no tank")
+    }
+  }
+
+  private def checkSideForTank(args: Arguments, n: Int) = owner.toGlobal(args.checkSide(n, ForgeDirection.SOUTH, ForgeDirection.NORTH, ForgeDirection.UP, ForgeDirection.DOWN))
+}

src/main/scala/li/cil/oc/server/component/robot/Robot.scala

@@ -535,33 +535,31 @@ class Robot(val robot: tileentity.Robot) extends ManagedComponent {
 
   @Callback
   def transferFluidTo(context: Context, args: Arguments): Array[AnyRef] = {
-    val index = checkSlot(args, 0)
+    val index = checkTank(args, 0)
     val count = args.optionalFluidCount(1)
     if (index == selectedTank || count == 0) {
       result(true)
     }
-    else result((getTank(selectedTank), getTank(index)) match {
+    else (getTank(selectedTank), getTank(index)) match {
       case (Some(from), Some(to)) =>
-        if (haveSameFluidType(from.getFluid, to.getFluid)) {
+        val drained = from.drain(count, false)
-          val space = to.getCapacity - to.getFluidAmount
+        val transferred = to.fill(drained, true)
-          val amount = math.min(count, space)
+        if (transferred > 0) {
-          if (amount > 0) {
+          from.drain(transferred, true)
-            to.fill(from.drain(amount, true), true)
+          robot.onInventoryChanged()
-            robot.onInventoryChanged()
+          result(true)
-            true
-          }
-          else false
         }
-        else if (count >= from.getFluidAmount) {
+        else if (count >= from.getFluidAmount && to.getCapacity >= from.getFluidAmount && from.getCapacity >= to.getFluidAmount) {
+          // Swap.
           val tmp = to.drain(to.getFluidAmount, true)
           to.fill(from.drain(from.getFluidAmount, true), true)
           from.fill(tmp, true)
           robot.onInventoryChanged()
-          true
+          result(true)
         }
-        else false
+        else result(Unit, "incompatible or no fluid")
-      case _ => false
+      case _ => result(Unit, "invalid index")
-    })
+    }
   }
 
   @Callback
@@ -670,40 +668,6 @@ class Robot(val robot: tileentity.Robot) extends ManagedComponent {
     }
   }
 
-//  @Callback
-//  def getFluidInfo(context: Context, args: Arguments): Array[AnyRef] = {
-//    robot.getSelectedTank match {
-//      case Some(component) =>
-//        component.getInfo match {
-//          case (info: FluidTankInfo) => info.fluid match {
-//            case (fluid: FluidStack) => result(fluid.getFluid.getName, fluid.getFluid.getLocalizedName, fluid.amount, info.capacity)
-//            case _ => result(Unit, "no fluid")
-//          }
-//          case _ => result(Unit, "no fluid")
-//        }
-//      case None => result(Unit, "no Container Selected")
-//    }
-//  }
-//
-//  @Callback
-//  def storeFluid(context: Context, args: Arguments): Array[AnyRef] = {
-//    val stack = stackInSlot(selectedSlot)
-//    stack match {
-//      case Some(item) => return result(FluidContainerRegistry.isBucket(item), FluidContainerRegistry.isContainer(item))
-//      case None =>
-//    }
-//    result(Unit, "Not a valid inventory")
-//  }
-//
-//  @Callback
-//  def ejectFluid(context: Context, args: Arguments): Array[AnyRef] = {
-//    val stack = stackInSlot(selectedSlot)
-//    stack match {
-//      case Some(item) => result(true)
-//      case None => result(Unit, "Not a valid inventory")
-//    }
-//  }
-
   // ----------------------------------------------------------------------- //
 
   override def onConnect(node: Node) {
@@ -837,9 +801,12 @@ class Robot(val robot: tileentity.Robot) extends ManagedComponent {
 
   private def stackInSlot(slot: Int) = Option(robot.getStackInSlot(slot))
 
-  private def getTank(tank: Int) = robot.getFluidTank(tank)
+  private def getTank(index: Int) = robot.getFluidTank(index)
 
-  private def fluidInTank(tank: Int) = getTank(tank).map(_.getFluid)
+  private def fluidInTank(index: Int) = getTank(index) match {
+    case Some(tank) => Option(tank.getFluid)
+    case _ => None
+  }
 
   // ----------------------------------------------------------------------- //
 

src/main/scala/li/cil/oc/server/driver/converter/FluidStack.scala

@@ -0,0 +1,25 @@
+package li.cil.oc.server.driver.converter
+
+import java.util
+
+import li.cil.oc.{Settings, api}
+
+import scala.collection.convert.WrapAsScala._
+
+object FluidStack extends api.driver.Converter {
+  override def convert(value: scala.Any, output: util.Map[AnyRef, AnyRef]) =
+    value match {
+      case stack: net.minecraftforge.fluids.FluidStack =>
+        if (Settings.get.insertIdsInConverters) {
+          output += "id" -> Int.box(stack.fluidID)
+        }
+        output += "amount" -> Int.box(stack.amount)
+        output += "hasTag" -> Boolean.box(stack.tag != null)
+        val fluid = stack.getFluid
+        if (fluid != null) {
+          output += "name" -> fluid.getName
+          output += "label" -> fluid.getLocalizedName
+        }
+      case _ =>
+    }
+}

src/main/scala/li/cil/oc/server/driver/converter/FluidTankInfo.scala

@@ -13,13 +13,7 @@ object FluidTankInfo extends api.driver.Converter {
       case tankInfo: fluids.FluidTankInfo =>
         output += "capacity" -> Int.box(tankInfo.capacity)
         if (tankInfo.fluid != null) {
-          output += "amount" -> Int.box(tankInfo.fluid.amount)
+          FluidStack.convert(tankInfo.fluid, output)
-          output += "id" -> Int.box(tankInfo.fluid.fluidID)
-          val fluid = tankInfo.fluid.getFluid
-          if (fluid != null) {
-            output += "name" -> fluid.getName
-            output += "label" -> fluid.getLocalizedName
-          }
         }
         else output += "amount" -> Int.box(0)
       case _ =>

src/main/scala/li/cil/oc/server/driver/converter/ItemStack.scala

@@ -2,7 +2,7 @@ package li.cil.oc.server.driver.converter
 
 import java.util
 
-import li.cil.oc.api
+import li.cil.oc.{Settings, api}
 import net.minecraft.item
 
 import scala.collection.convert.WrapAsScala._
@@ -11,7 +11,9 @@ object ItemStack extends api.driver.Converter {
   override def convert(value: AnyRef, output: util.Map[AnyRef, AnyRef]) =
     value match {
       case stack: item.ItemStack =>
-        output += "id" -> Int.box(stack.itemID)
+        if (Settings.get.insertIdsInConverters) {
+          output += "id" -> Int.box(stack.itemID)
+        }
         output += "damage" -> Int.box(stack.getItemDamage)
         output += "maxDamage" -> Int.box(stack.getMaxDamage)
         output += "size" -> Int.box(stack.stackSize)

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

@@ -0,0 +1,21 @@
+package li.cil.oc.server.driver.item
+
+import li.cil.oc.api
+import li.cil.oc.api.driver.{Container, Slot}
+import li.cil.oc.common.Tier
+import li.cil.oc.common.tileentity.Robot
+import li.cil.oc.server.component
+import net.minecraft.item.ItemStack
+
+object UpgradeTankController extends Item {
+  override def worksWith(stack: ItemStack) = isOneOf(stack, api.Items.get("tankControllerUpgrade"))
+
+  override def createEnvironment(stack: ItemStack, container: Container) = container match {
+    case robot: Container with Robot => new component.UpgradeTankController(robot)
+    case _ => null
+  }
+
+  override def slot(stack: ItemStack) = Slot.Upgrade
+
+  override def tier(stack: ItemStack) = Tier.Two
+}